strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    __slots__ = [
   23        'bind_interface',
   24        'certificate_authority',
   25        'client_certificate',
   26        'client_key',
   27        'egress_filter',
   28        'healthcheck_namespace',
   29        'healthy',
   30        'hostname',
   31        'id',
   32        'name',
   33        'port',
   34        'port_override',
   35        'remote_identity_group_id',
   36        'remote_identity_healthcheck_username',
   37        'secret_store_id',
   38        'tags',
   39    ]
   40
   41    def __init__(
   42        self,
   43        bind_interface=None,
   44        certificate_authority=None,
   45        client_certificate=None,
   46        client_key=None,
   47        egress_filter=None,
   48        healthcheck_namespace=None,
   49        healthy=None,
   50        hostname=None,
   51        id=None,
   52        name=None,
   53        port=None,
   54        port_override=None,
   55        remote_identity_group_id=None,
   56        remote_identity_healthcheck_username=None,
   57        secret_store_id=None,
   58        tags=None,
   59    ):
   60        self.bind_interface = bind_interface if bind_interface is not None else ''
   61        '''
   62         Bind interface
   63        '''
   64        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   65        self.client_certificate = client_certificate if client_certificate is not None else ''
   66        self.client_key = client_key if client_key is not None else ''
   67        self.egress_filter = egress_filter if egress_filter is not None else ''
   68        '''
   69         A filter applied to the routing logic to pin datasource to nodes.
   70        '''
   71        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   72        '''
   73         The path used to check the health of your connection.  Defaults to `default`.
   74        '''
   75        self.healthy = healthy if healthy is not None else False
   76        '''
   77         True if the datasource is reachable and the credentials are valid.
   78        '''
   79        self.hostname = hostname if hostname is not None else ''
   80        self.id = id if id is not None else ''
   81        '''
   82         Unique identifier of the Resource.
   83        '''
   84        self.name = name if name is not None else ''
   85        '''
   86         Unique human-readable name of the Resource.
   87        '''
   88        self.port = port if port is not None else 0
   89        self.port_override = port_override if port_override is not None else 0
   90        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
   91        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
   92        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
   93        '''
   94         ID of the secret store containing credentials for this resource, if any.
   95        '''
   96        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
   97        '''
   98         Tags is a map of key, value pairs.
   99        '''
  100
  101    def __repr__(self):
  102        return '<sdm.AKS ' + \
  103            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  104            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  105            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  106            'client_key: ' + repr(self.client_key) + ' ' +\
  107            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  108            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  109            'healthy: ' + repr(self.healthy) + ' ' +\
  110            'hostname: ' + repr(self.hostname) + ' ' +\
  111            'id: ' + repr(self.id) + ' ' +\
  112            'name: ' + repr(self.name) + ' ' +\
  113            'port: ' + repr(self.port) + ' ' +\
  114            'port_override: ' + repr(self.port_override) + ' ' +\
  115            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  116            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  117            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  118            'tags: ' + repr(self.tags) + ' ' +\
  119            '>'
  120
  121    def to_dict(self):
  122        return {
  123            'bind_interface': self.bind_interface,
  124            'certificate_authority': self.certificate_authority,
  125            'client_certificate': self.client_certificate,
  126            'client_key': self.client_key,
  127            'egress_filter': self.egress_filter,
  128            'healthcheck_namespace': self.healthcheck_namespace,
  129            'healthy': self.healthy,
  130            'hostname': self.hostname,
  131            'id': self.id,
  132            'name': self.name,
  133            'port': self.port,
  134            'port_override': self.port_override,
  135            'remote_identity_group_id': self.remote_identity_group_id,
  136            'remote_identity_healthcheck_username':
  137            self.remote_identity_healthcheck_username,
  138            'secret_store_id': self.secret_store_id,
  139            'tags': self.tags,
  140        }
  141
  142    @classmethod
  143    def from_dict(cls, d):
  144        return cls(
  145            bind_interface=d.get('bind_interface'),
  146            certificate_authority=d.get('certificate_authority'),
  147            client_certificate=d.get('client_certificate'),
  148            client_key=d.get('client_key'),
  149            egress_filter=d.get('egress_filter'),
  150            healthcheck_namespace=d.get('healthcheck_namespace'),
  151            healthy=d.get('healthy'),
  152            hostname=d.get('hostname'),
  153            id=d.get('id'),
  154            name=d.get('name'),
  155            port=d.get('port'),
  156            port_override=d.get('port_override'),
  157            remote_identity_group_id=d.get('remote_identity_group_id'),
  158            remote_identity_healthcheck_username=d.get(
  159                'remote_identity_healthcheck_username'),
  160            secret_store_id=d.get('secret_store_id'),
  161            tags=d.get('tags'),
  162        )
  163
  164
  165class AKSBasicAuth:
  166    __slots__ = [
  167        'bind_interface',
  168        'egress_filter',
  169        'healthcheck_namespace',
  170        'healthy',
  171        'hostname',
  172        'id',
  173        'name',
  174        'password',
  175        'port',
  176        'port_override',
  177        'secret_store_id',
  178        'tags',
  179        'username',
  180    ]
  181
  182    def __init__(
  183        self,
  184        bind_interface=None,
  185        egress_filter=None,
  186        healthcheck_namespace=None,
  187        healthy=None,
  188        hostname=None,
  189        id=None,
  190        name=None,
  191        password=None,
  192        port=None,
  193        port_override=None,
  194        secret_store_id=None,
  195        tags=None,
  196        username=None,
  197    ):
  198        self.bind_interface = bind_interface if bind_interface is not None else ''
  199        '''
  200         Bind interface
  201        '''
  202        self.egress_filter = egress_filter if egress_filter is not None else ''
  203        '''
  204         A filter applied to the routing logic to pin datasource to nodes.
  205        '''
  206        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  207        '''
  208         The path used to check the health of your connection.  Defaults to `default`.
  209        '''
  210        self.healthy = healthy if healthy is not None else False
  211        '''
  212         True if the datasource is reachable and the credentials are valid.
  213        '''
  214        self.hostname = hostname if hostname is not None else ''
  215        self.id = id if id is not None else ''
  216        '''
  217         Unique identifier of the Resource.
  218        '''
  219        self.name = name if name is not None else ''
  220        '''
  221         Unique human-readable name of the Resource.
  222        '''
  223        self.password = password if password is not None else ''
  224        self.port = port if port is not None else 0
  225        self.port_override = port_override if port_override is not None else 0
  226        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  227        '''
  228         ID of the secret store containing credentials for this resource, if any.
  229        '''
  230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  231        '''
  232         Tags is a map of key, value pairs.
  233        '''
  234        self.username = username if username is not None else ''
  235
  236    def __repr__(self):
  237        return '<sdm.AKSBasicAuth ' + \
  238            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  239            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  240            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  241            'healthy: ' + repr(self.healthy) + ' ' +\
  242            'hostname: ' + repr(self.hostname) + ' ' +\
  243            'id: ' + repr(self.id) + ' ' +\
  244            'name: ' + repr(self.name) + ' ' +\
  245            'password: ' + repr(self.password) + ' ' +\
  246            'port: ' + repr(self.port) + ' ' +\
  247            'port_override: ' + repr(self.port_override) + ' ' +\
  248            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  249            'tags: ' + repr(self.tags) + ' ' +\
  250            'username: ' + repr(self.username) + ' ' +\
  251            '>'
  252
  253    def to_dict(self):
  254        return {
  255            'bind_interface': self.bind_interface,
  256            'egress_filter': self.egress_filter,
  257            'healthcheck_namespace': self.healthcheck_namespace,
  258            'healthy': self.healthy,
  259            'hostname': self.hostname,
  260            'id': self.id,
  261            'name': self.name,
  262            'password': self.password,
  263            'port': self.port,
  264            'port_override': self.port_override,
  265            'secret_store_id': self.secret_store_id,
  266            'tags': self.tags,
  267            'username': self.username,
  268        }
  269
  270    @classmethod
  271    def from_dict(cls, d):
  272        return cls(
  273            bind_interface=d.get('bind_interface'),
  274            egress_filter=d.get('egress_filter'),
  275            healthcheck_namespace=d.get('healthcheck_namespace'),
  276            healthy=d.get('healthy'),
  277            hostname=d.get('hostname'),
  278            id=d.get('id'),
  279            name=d.get('name'),
  280            password=d.get('password'),
  281            port=d.get('port'),
  282            port_override=d.get('port_override'),
  283            secret_store_id=d.get('secret_store_id'),
  284            tags=d.get('tags'),
  285            username=d.get('username'),
  286        )
  287
  288
  289class AKSServiceAccount:
  290    __slots__ = [
  291        'bind_interface',
  292        'egress_filter',
  293        'healthcheck_namespace',
  294        'healthy',
  295        'hostname',
  296        'id',
  297        'name',
  298        'port',
  299        'port_override',
  300        'remote_identity_group_id',
  301        'remote_identity_healthcheck_username',
  302        'secret_store_id',
  303        'tags',
  304        'token',
  305    ]
  306
  307    def __init__(
  308        self,
  309        bind_interface=None,
  310        egress_filter=None,
  311        healthcheck_namespace=None,
  312        healthy=None,
  313        hostname=None,
  314        id=None,
  315        name=None,
  316        port=None,
  317        port_override=None,
  318        remote_identity_group_id=None,
  319        remote_identity_healthcheck_username=None,
  320        secret_store_id=None,
  321        tags=None,
  322        token=None,
  323    ):
  324        self.bind_interface = bind_interface if bind_interface is not None else ''
  325        '''
  326         Bind interface
  327        '''
  328        self.egress_filter = egress_filter if egress_filter is not None else ''
  329        '''
  330         A filter applied to the routing logic to pin datasource to nodes.
  331        '''
  332        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  333        '''
  334         The path used to check the health of your connection.  Defaults to `default`.
  335        '''
  336        self.healthy = healthy if healthy is not None else False
  337        '''
  338         True if the datasource is reachable and the credentials are valid.
  339        '''
  340        self.hostname = hostname if hostname is not None else ''
  341        self.id = id if id is not None else ''
  342        '''
  343         Unique identifier of the Resource.
  344        '''
  345        self.name = name if name is not None else ''
  346        '''
  347         Unique human-readable name of the Resource.
  348        '''
  349        self.port = port if port is not None else 0
  350        self.port_override = port_override if port_override is not None else 0
  351        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  352        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  353        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  354        '''
  355         ID of the secret store containing credentials for this resource, if any.
  356        '''
  357        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  358        '''
  359         Tags is a map of key, value pairs.
  360        '''
  361        self.token = token if token is not None else ''
  362
  363    def __repr__(self):
  364        return '<sdm.AKSServiceAccount ' + \
  365            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  366            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  367            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  368            'healthy: ' + repr(self.healthy) + ' ' +\
  369            'hostname: ' + repr(self.hostname) + ' ' +\
  370            'id: ' + repr(self.id) + ' ' +\
  371            'name: ' + repr(self.name) + ' ' +\
  372            'port: ' + repr(self.port) + ' ' +\
  373            'port_override: ' + repr(self.port_override) + ' ' +\
  374            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  375            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  376            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  377            'tags: ' + repr(self.tags) + ' ' +\
  378            'token: ' + repr(self.token) + ' ' +\
  379            '>'
  380
  381    def to_dict(self):
  382        return {
  383            'bind_interface': self.bind_interface,
  384            'egress_filter': self.egress_filter,
  385            'healthcheck_namespace': self.healthcheck_namespace,
  386            'healthy': self.healthy,
  387            'hostname': self.hostname,
  388            'id': self.id,
  389            'name': self.name,
  390            'port': self.port,
  391            'port_override': self.port_override,
  392            'remote_identity_group_id': self.remote_identity_group_id,
  393            'remote_identity_healthcheck_username':
  394            self.remote_identity_healthcheck_username,
  395            'secret_store_id': self.secret_store_id,
  396            'tags': self.tags,
  397            'token': self.token,
  398        }
  399
  400    @classmethod
  401    def from_dict(cls, d):
  402        return cls(
  403            bind_interface=d.get('bind_interface'),
  404            egress_filter=d.get('egress_filter'),
  405            healthcheck_namespace=d.get('healthcheck_namespace'),
  406            healthy=d.get('healthy'),
  407            hostname=d.get('hostname'),
  408            id=d.get('id'),
  409            name=d.get('name'),
  410            port=d.get('port'),
  411            port_override=d.get('port_override'),
  412            remote_identity_group_id=d.get('remote_identity_group_id'),
  413            remote_identity_healthcheck_username=d.get(
  414                'remote_identity_healthcheck_username'),
  415            secret_store_id=d.get('secret_store_id'),
  416            tags=d.get('tags'),
  417            token=d.get('token'),
  418        )
  419
  420
  421class AKSServiceAccountUserImpersonation:
  422    __slots__ = [
  423        'bind_interface',
  424        'egress_filter',
  425        'healthcheck_namespace',
  426        'healthy',
  427        'hostname',
  428        'id',
  429        'name',
  430        'port',
  431        'port_override',
  432        'secret_store_id',
  433        'tags',
  434        'token',
  435    ]
  436
  437    def __init__(
  438        self,
  439        bind_interface=None,
  440        egress_filter=None,
  441        healthcheck_namespace=None,
  442        healthy=None,
  443        hostname=None,
  444        id=None,
  445        name=None,
  446        port=None,
  447        port_override=None,
  448        secret_store_id=None,
  449        tags=None,
  450        token=None,
  451    ):
  452        self.bind_interface = bind_interface if bind_interface is not None else ''
  453        '''
  454         Bind interface
  455        '''
  456        self.egress_filter = egress_filter if egress_filter is not None else ''
  457        '''
  458         A filter applied to the routing logic to pin datasource to nodes.
  459        '''
  460        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  461        '''
  462         The path used to check the health of your connection.  Defaults to `default`.
  463        '''
  464        self.healthy = healthy if healthy is not None else False
  465        '''
  466         True if the datasource is reachable and the credentials are valid.
  467        '''
  468        self.hostname = hostname if hostname is not None else ''
  469        self.id = id if id is not None else ''
  470        '''
  471         Unique identifier of the Resource.
  472        '''
  473        self.name = name if name is not None else ''
  474        '''
  475         Unique human-readable name of the Resource.
  476        '''
  477        self.port = port if port is not None else 0
  478        self.port_override = port_override if port_override is not None else 0
  479        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  480        '''
  481         ID of the secret store containing credentials for this resource, if any.
  482        '''
  483        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  484        '''
  485         Tags is a map of key, value pairs.
  486        '''
  487        self.token = token if token is not None else ''
  488
  489    def __repr__(self):
  490        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  491            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  492            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  493            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  494            'healthy: ' + repr(self.healthy) + ' ' +\
  495            'hostname: ' + repr(self.hostname) + ' ' +\
  496            'id: ' + repr(self.id) + ' ' +\
  497            'name: ' + repr(self.name) + ' ' +\
  498            'port: ' + repr(self.port) + ' ' +\
  499            'port_override: ' + repr(self.port_override) + ' ' +\
  500            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  501            'tags: ' + repr(self.tags) + ' ' +\
  502            'token: ' + repr(self.token) + ' ' +\
  503            '>'
  504
  505    def to_dict(self):
  506        return {
  507            'bind_interface': self.bind_interface,
  508            'egress_filter': self.egress_filter,
  509            'healthcheck_namespace': self.healthcheck_namespace,
  510            'healthy': self.healthy,
  511            'hostname': self.hostname,
  512            'id': self.id,
  513            'name': self.name,
  514            'port': self.port,
  515            'port_override': self.port_override,
  516            'secret_store_id': self.secret_store_id,
  517            'tags': self.tags,
  518            'token': self.token,
  519        }
  520
  521    @classmethod
  522    def from_dict(cls, d):
  523        return cls(
  524            bind_interface=d.get('bind_interface'),
  525            egress_filter=d.get('egress_filter'),
  526            healthcheck_namespace=d.get('healthcheck_namespace'),
  527            healthy=d.get('healthy'),
  528            hostname=d.get('hostname'),
  529            id=d.get('id'),
  530            name=d.get('name'),
  531            port=d.get('port'),
  532            port_override=d.get('port_override'),
  533            secret_store_id=d.get('secret_store_id'),
  534            tags=d.get('tags'),
  535            token=d.get('token'),
  536        )
  537
  538
  539class AKSUserImpersonation:
  540    __slots__ = [
  541        'bind_interface',
  542        'certificate_authority',
  543        'client_certificate',
  544        'client_key',
  545        'egress_filter',
  546        'healthcheck_namespace',
  547        'healthy',
  548        'hostname',
  549        'id',
  550        'name',
  551        'port',
  552        'port_override',
  553        'secret_store_id',
  554        'tags',
  555    ]
  556
  557    def __init__(
  558        self,
  559        bind_interface=None,
  560        certificate_authority=None,
  561        client_certificate=None,
  562        client_key=None,
  563        egress_filter=None,
  564        healthcheck_namespace=None,
  565        healthy=None,
  566        hostname=None,
  567        id=None,
  568        name=None,
  569        port=None,
  570        port_override=None,
  571        secret_store_id=None,
  572        tags=None,
  573    ):
  574        self.bind_interface = bind_interface if bind_interface is not None else ''
  575        '''
  576         Bind interface
  577        '''
  578        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  579        self.client_certificate = client_certificate if client_certificate is not None else ''
  580        self.client_key = client_key if client_key is not None else ''
  581        self.egress_filter = egress_filter if egress_filter is not None else ''
  582        '''
  583         A filter applied to the routing logic to pin datasource to nodes.
  584        '''
  585        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  586        '''
  587         The path used to check the health of your connection.  Defaults to `default`.
  588        '''
  589        self.healthy = healthy if healthy is not None else False
  590        '''
  591         True if the datasource is reachable and the credentials are valid.
  592        '''
  593        self.hostname = hostname if hostname is not None else ''
  594        self.id = id if id is not None else ''
  595        '''
  596         Unique identifier of the Resource.
  597        '''
  598        self.name = name if name is not None else ''
  599        '''
  600         Unique human-readable name of the Resource.
  601        '''
  602        self.port = port if port is not None else 0
  603        self.port_override = port_override if port_override is not None else 0
  604        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  605        '''
  606         ID of the secret store containing credentials for this resource, if any.
  607        '''
  608        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  609        '''
  610         Tags is a map of key, value pairs.
  611        '''
  612
  613    def __repr__(self):
  614        return '<sdm.AKSUserImpersonation ' + \
  615            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  616            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  617            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  618            'client_key: ' + repr(self.client_key) + ' ' +\
  619            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  620            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  621            'healthy: ' + repr(self.healthy) + ' ' +\
  622            'hostname: ' + repr(self.hostname) + ' ' +\
  623            'id: ' + repr(self.id) + ' ' +\
  624            'name: ' + repr(self.name) + ' ' +\
  625            'port: ' + repr(self.port) + ' ' +\
  626            'port_override: ' + repr(self.port_override) + ' ' +\
  627            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  628            'tags: ' + repr(self.tags) + ' ' +\
  629            '>'
  630
  631    def to_dict(self):
  632        return {
  633            'bind_interface': self.bind_interface,
  634            'certificate_authority': self.certificate_authority,
  635            'client_certificate': self.client_certificate,
  636            'client_key': self.client_key,
  637            'egress_filter': self.egress_filter,
  638            'healthcheck_namespace': self.healthcheck_namespace,
  639            'healthy': self.healthy,
  640            'hostname': self.hostname,
  641            'id': self.id,
  642            'name': self.name,
  643            'port': self.port,
  644            'port_override': self.port_override,
  645            'secret_store_id': self.secret_store_id,
  646            'tags': self.tags,
  647        }
  648
  649    @classmethod
  650    def from_dict(cls, d):
  651        return cls(
  652            bind_interface=d.get('bind_interface'),
  653            certificate_authority=d.get('certificate_authority'),
  654            client_certificate=d.get('client_certificate'),
  655            client_key=d.get('client_key'),
  656            egress_filter=d.get('egress_filter'),
  657            healthcheck_namespace=d.get('healthcheck_namespace'),
  658            healthy=d.get('healthy'),
  659            hostname=d.get('hostname'),
  660            id=d.get('id'),
  661            name=d.get('name'),
  662            port=d.get('port'),
  663            port_override=d.get('port_override'),
  664            secret_store_id=d.get('secret_store_id'),
  665            tags=d.get('tags'),
  666        )
  667
  668
  669class AWS:
  670    __slots__ = [
  671        'access_key',
  672        'bind_interface',
  673        'egress_filter',
  674        'healthcheck_region',
  675        'healthy',
  676        'id',
  677        'name',
  678        'role_arn',
  679        'role_external_id',
  680        'secret_access_key',
  681        'secret_store_id',
  682        'tags',
  683    ]
  684
  685    def __init__(
  686        self,
  687        access_key=None,
  688        bind_interface=None,
  689        egress_filter=None,
  690        healthcheck_region=None,
  691        healthy=None,
  692        id=None,
  693        name=None,
  694        role_arn=None,
  695        role_external_id=None,
  696        secret_access_key=None,
  697        secret_store_id=None,
  698        tags=None,
  699    ):
  700        self.access_key = access_key if access_key is not None else ''
  701        self.bind_interface = bind_interface if bind_interface is not None else ''
  702        '''
  703         Bind interface
  704        '''
  705        self.egress_filter = egress_filter if egress_filter is not None else ''
  706        '''
  707         A filter applied to the routing logic to pin datasource to nodes.
  708        '''
  709        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  710        self.healthy = healthy if healthy is not None else False
  711        '''
  712         True if the datasource is reachable and the credentials are valid.
  713        '''
  714        self.id = id if id is not None else ''
  715        '''
  716         Unique identifier of the Resource.
  717        '''
  718        self.name = name if name is not None else ''
  719        '''
  720         Unique human-readable name of the Resource.
  721        '''
  722        self.role_arn = role_arn if role_arn is not None else ''
  723        self.role_external_id = role_external_id if role_external_id is not None else ''
  724        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  725        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  726        '''
  727         ID of the secret store containing credentials for this resource, if any.
  728        '''
  729        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  730        '''
  731         Tags is a map of key, value pairs.
  732        '''
  733
  734    def __repr__(self):
  735        return '<sdm.AWS ' + \
  736            'access_key: ' + repr(self.access_key) + ' ' +\
  737            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  738            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  739            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  740            'healthy: ' + repr(self.healthy) + ' ' +\
  741            'id: ' + repr(self.id) + ' ' +\
  742            'name: ' + repr(self.name) + ' ' +\
  743            'role_arn: ' + repr(self.role_arn) + ' ' +\
  744            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  745            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  746            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  747            'tags: ' + repr(self.tags) + ' ' +\
  748            '>'
  749
  750    def to_dict(self):
  751        return {
  752            'access_key': self.access_key,
  753            'bind_interface': self.bind_interface,
  754            'egress_filter': self.egress_filter,
  755            'healthcheck_region': self.healthcheck_region,
  756            'healthy': self.healthy,
  757            'id': self.id,
  758            'name': self.name,
  759            'role_arn': self.role_arn,
  760            'role_external_id': self.role_external_id,
  761            'secret_access_key': self.secret_access_key,
  762            'secret_store_id': self.secret_store_id,
  763            'tags': self.tags,
  764        }
  765
  766    @classmethod
  767    def from_dict(cls, d):
  768        return cls(
  769            access_key=d.get('access_key'),
  770            bind_interface=d.get('bind_interface'),
  771            egress_filter=d.get('egress_filter'),
  772            healthcheck_region=d.get('healthcheck_region'),
  773            healthy=d.get('healthy'),
  774            id=d.get('id'),
  775            name=d.get('name'),
  776            role_arn=d.get('role_arn'),
  777            role_external_id=d.get('role_external_id'),
  778            secret_access_key=d.get('secret_access_key'),
  779            secret_store_id=d.get('secret_store_id'),
  780            tags=d.get('tags'),
  781        )
  782
  783
  784class AWSConsole:
  785    '''
  786    AWSConsole is currently unstable, and its API may change, or it may be removed,
  787    without a major version bump.
  788    '''
  789    __slots__ = [
  790        'bind_interface',
  791        'egress_filter',
  792        'enable_env_variables',
  793        'healthy',
  794        'id',
  795        'name',
  796        'port_override',
  797        'region',
  798        'remote_identity_group_id',
  799        'remote_identity_healthcheck_username',
  800        'role_arn',
  801        'role_external_id',
  802        'secret_store_id',
  803        'session_expiry',
  804        'subdomain',
  805        'tags',
  806    ]
  807
  808    def __init__(
  809        self,
  810        bind_interface=None,
  811        egress_filter=None,
  812        enable_env_variables=None,
  813        healthy=None,
  814        id=None,
  815        name=None,
  816        port_override=None,
  817        region=None,
  818        remote_identity_group_id=None,
  819        remote_identity_healthcheck_username=None,
  820        role_arn=None,
  821        role_external_id=None,
  822        secret_store_id=None,
  823        session_expiry=None,
  824        subdomain=None,
  825        tags=None,
  826    ):
  827        self.bind_interface = bind_interface if bind_interface is not None else ''
  828        '''
  829         Bind interface
  830        '''
  831        self.egress_filter = egress_filter if egress_filter is not None else ''
  832        '''
  833         A filter applied to the routing logic to pin datasource to nodes.
  834        '''
  835        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
  836        self.healthy = healthy if healthy is not None else False
  837        '''
  838         True if the datasource is reachable and the credentials are valid.
  839        '''
  840        self.id = id if id is not None else ''
  841        '''
  842         Unique identifier of the Resource.
  843        '''
  844        self.name = name if name is not None else ''
  845        '''
  846         Unique human-readable name of the Resource.
  847        '''
  848        self.port_override = port_override if port_override is not None else 0
  849        self.region = region if region is not None else ''
  850        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  851        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  852        self.role_arn = role_arn if role_arn is not None else ''
  853        self.role_external_id = role_external_id if role_external_id is not None else ''
  854        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  855        '''
  856         ID of the secret store containing credentials for this resource, if any.
  857        '''
  858        self.session_expiry = session_expiry if session_expiry is not None else 0
  859        self.subdomain = subdomain if subdomain is not None else ''
  860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  861        '''
  862         Tags is a map of key, value pairs.
  863        '''
  864
  865    def __repr__(self):
  866        return '<sdm.AWSConsole ' + \
  867            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  868            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  869            'enable_env_variables: ' + repr(self.enable_env_variables) + ' ' +\
  870            'healthy: ' + repr(self.healthy) + ' ' +\
  871            'id: ' + repr(self.id) + ' ' +\
  872            'name: ' + repr(self.name) + ' ' +\
  873            'port_override: ' + repr(self.port_override) + ' ' +\
  874            'region: ' + repr(self.region) + ' ' +\
  875            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  876            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  877            'role_arn: ' + repr(self.role_arn) + ' ' +\
  878            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  879            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  880            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
  881            'subdomain: ' + repr(self.subdomain) + ' ' +\
  882            'tags: ' + repr(self.tags) + ' ' +\
  883            '>'
  884
  885    def to_dict(self):
  886        return {
  887            'bind_interface': self.bind_interface,
  888            'egress_filter': self.egress_filter,
  889            'enable_env_variables': self.enable_env_variables,
  890            'healthy': self.healthy,
  891            'id': self.id,
  892            'name': self.name,
  893            'port_override': self.port_override,
  894            'region': self.region,
  895            'remote_identity_group_id': self.remote_identity_group_id,
  896            'remote_identity_healthcheck_username':
  897            self.remote_identity_healthcheck_username,
  898            'role_arn': self.role_arn,
  899            'role_external_id': self.role_external_id,
  900            'secret_store_id': self.secret_store_id,
  901            'session_expiry': self.session_expiry,
  902            'subdomain': self.subdomain,
  903            'tags': self.tags,
  904        }
  905
  906    @classmethod
  907    def from_dict(cls, d):
  908        return cls(
  909            bind_interface=d.get('bind_interface'),
  910            egress_filter=d.get('egress_filter'),
  911            enable_env_variables=d.get('enable_env_variables'),
  912            healthy=d.get('healthy'),
  913            id=d.get('id'),
  914            name=d.get('name'),
  915            port_override=d.get('port_override'),
  916            region=d.get('region'),
  917            remote_identity_group_id=d.get('remote_identity_group_id'),
  918            remote_identity_healthcheck_username=d.get(
  919                'remote_identity_healthcheck_username'),
  920            role_arn=d.get('role_arn'),
  921            role_external_id=d.get('role_external_id'),
  922            secret_store_id=d.get('secret_store_id'),
  923            session_expiry=d.get('session_expiry'),
  924            subdomain=d.get('subdomain'),
  925            tags=d.get('tags'),
  926        )
  927
  928
  929class AWSConsoleStaticKeyPair:
  930    '''
  931    AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed,
  932    without a major version bump.
  933    '''
  934    __slots__ = [
  935        'access_key',
  936        'bind_interface',
  937        'egress_filter',
  938        'healthy',
  939        'id',
  940        'name',
  941        'port_override',
  942        'region',
  943        'remote_identity_group_id',
  944        'remote_identity_healthcheck_username',
  945        'role_arn',
  946        'role_external_id',
  947        'secret_access_key',
  948        'secret_store_id',
  949        'session_expiry',
  950        'subdomain',
  951        'tags',
  952    ]
  953
  954    def __init__(
  955        self,
  956        access_key=None,
  957        bind_interface=None,
  958        egress_filter=None,
  959        healthy=None,
  960        id=None,
  961        name=None,
  962        port_override=None,
  963        region=None,
  964        remote_identity_group_id=None,
  965        remote_identity_healthcheck_username=None,
  966        role_arn=None,
  967        role_external_id=None,
  968        secret_access_key=None,
  969        secret_store_id=None,
  970        session_expiry=None,
  971        subdomain=None,
  972        tags=None,
  973    ):
  974        self.access_key = access_key if access_key is not None else ''
  975        self.bind_interface = bind_interface if bind_interface is not None else ''
  976        '''
  977         Bind interface
  978        '''
  979        self.egress_filter = egress_filter if egress_filter is not None else ''
  980        '''
  981         A filter applied to the routing logic to pin datasource to nodes.
  982        '''
  983        self.healthy = healthy if healthy is not None else False
  984        '''
  985         True if the datasource is reachable and the credentials are valid.
  986        '''
  987        self.id = id if id is not None else ''
  988        '''
  989         Unique identifier of the Resource.
  990        '''
  991        self.name = name if name is not None else ''
  992        '''
  993         Unique human-readable name of the Resource.
  994        '''
  995        self.port_override = port_override if port_override is not None else 0
  996        self.region = region if region is not None else ''
  997        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  998        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  999        self.role_arn = role_arn if role_arn is not None else ''
 1000        self.role_external_id = role_external_id if role_external_id is not None else ''
 1001        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1002        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1003        '''
 1004         ID of the secret store containing credentials for this resource, if any.
 1005        '''
 1006        self.session_expiry = session_expiry if session_expiry is not None else 0
 1007        self.subdomain = subdomain if subdomain is not None else ''
 1008        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1009        '''
 1010         Tags is a map of key, value pairs.
 1011        '''
 1012
 1013    def __repr__(self):
 1014        return '<sdm.AWSConsoleStaticKeyPair ' + \
 1015            'access_key: ' + repr(self.access_key) + ' ' +\
 1016            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1017            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1018            'healthy: ' + repr(self.healthy) + ' ' +\
 1019            'id: ' + repr(self.id) + ' ' +\
 1020            'name: ' + repr(self.name) + ' ' +\
 1021            'port_override: ' + repr(self.port_override) + ' ' +\
 1022            'region: ' + repr(self.region) + ' ' +\
 1023            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1024            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1025            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1026            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1027            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1028            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1029            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
 1030            'subdomain: ' + repr(self.subdomain) + ' ' +\
 1031            'tags: ' + repr(self.tags) + ' ' +\
 1032            '>'
 1033
 1034    def to_dict(self):
 1035        return {
 1036            'access_key': self.access_key,
 1037            'bind_interface': self.bind_interface,
 1038            'egress_filter': self.egress_filter,
 1039            'healthy': self.healthy,
 1040            'id': self.id,
 1041            'name': self.name,
 1042            'port_override': self.port_override,
 1043            'region': self.region,
 1044            'remote_identity_group_id': self.remote_identity_group_id,
 1045            'remote_identity_healthcheck_username':
 1046            self.remote_identity_healthcheck_username,
 1047            'role_arn': self.role_arn,
 1048            'role_external_id': self.role_external_id,
 1049            'secret_access_key': self.secret_access_key,
 1050            'secret_store_id': self.secret_store_id,
 1051            'session_expiry': self.session_expiry,
 1052            'subdomain': self.subdomain,
 1053            'tags': self.tags,
 1054        }
 1055
 1056    @classmethod
 1057    def from_dict(cls, d):
 1058        return cls(
 1059            access_key=d.get('access_key'),
 1060            bind_interface=d.get('bind_interface'),
 1061            egress_filter=d.get('egress_filter'),
 1062            healthy=d.get('healthy'),
 1063            id=d.get('id'),
 1064            name=d.get('name'),
 1065            port_override=d.get('port_override'),
 1066            region=d.get('region'),
 1067            remote_identity_group_id=d.get('remote_identity_group_id'),
 1068            remote_identity_healthcheck_username=d.get(
 1069                'remote_identity_healthcheck_username'),
 1070            role_arn=d.get('role_arn'),
 1071            role_external_id=d.get('role_external_id'),
 1072            secret_access_key=d.get('secret_access_key'),
 1073            secret_store_id=d.get('secret_store_id'),
 1074            session_expiry=d.get('session_expiry'),
 1075            subdomain=d.get('subdomain'),
 1076            tags=d.get('tags'),
 1077        )
 1078
 1079
 1080class AWSStore:
 1081    __slots__ = [
 1082        'id',
 1083        'name',
 1084        'region',
 1085        'tags',
 1086    ]
 1087
 1088    def __init__(
 1089        self,
 1090        id=None,
 1091        name=None,
 1092        region=None,
 1093        tags=None,
 1094    ):
 1095        self.id = id if id is not None else ''
 1096        '''
 1097         Unique identifier of the SecretStore.
 1098        '''
 1099        self.name = name if name is not None else ''
 1100        '''
 1101         Unique human-readable name of the SecretStore.
 1102        '''
 1103        self.region = region if region is not None else ''
 1104        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1105        '''
 1106         Tags is a map of key, value pairs.
 1107        '''
 1108
 1109    def __repr__(self):
 1110        return '<sdm.AWSStore ' + \
 1111            'id: ' + repr(self.id) + ' ' +\
 1112            'name: ' + repr(self.name) + ' ' +\
 1113            'region: ' + repr(self.region) + ' ' +\
 1114            'tags: ' + repr(self.tags) + ' ' +\
 1115            '>'
 1116
 1117    def to_dict(self):
 1118        return {
 1119            'id': self.id,
 1120            'name': self.name,
 1121            'region': self.region,
 1122            'tags': self.tags,
 1123        }
 1124
 1125    @classmethod
 1126    def from_dict(cls, d):
 1127        return cls(
 1128            id=d.get('id'),
 1129            name=d.get('name'),
 1130            region=d.get('region'),
 1131            tags=d.get('tags'),
 1132        )
 1133
 1134
 1135class AccountAttachment:
 1136    '''
 1137         AccountAttachments assign an account to a role.
 1138    '''
 1139    __slots__ = [
 1140        'account_id',
 1141        'id',
 1142        'role_id',
 1143    ]
 1144
 1145    def __init__(
 1146        self,
 1147        account_id=None,
 1148        id=None,
 1149        role_id=None,
 1150    ):
 1151        self.account_id = account_id if account_id is not None else ''
 1152        '''
 1153         The id of the account of this AccountAttachment.
 1154        '''
 1155        self.id = id if id is not None else ''
 1156        '''
 1157         Unique identifier of the AccountAttachment.
 1158        '''
 1159        self.role_id = role_id if role_id is not None else ''
 1160        '''
 1161         The id of the attached role of this AccountAttachment.
 1162        '''
 1163
 1164    def __repr__(self):
 1165        return '<sdm.AccountAttachment ' + \
 1166            'account_id: ' + repr(self.account_id) + ' ' +\
 1167            'id: ' + repr(self.id) + ' ' +\
 1168            'role_id: ' + repr(self.role_id) + ' ' +\
 1169            '>'
 1170
 1171    def to_dict(self):
 1172        return {
 1173            'account_id': self.account_id,
 1174            'id': self.id,
 1175            'role_id': self.role_id,
 1176        }
 1177
 1178    @classmethod
 1179    def from_dict(cls, d):
 1180        return cls(
 1181            account_id=d.get('account_id'),
 1182            id=d.get('id'),
 1183            role_id=d.get('role_id'),
 1184        )
 1185
 1186
 1187class AccountAttachmentCreateResponse:
 1188    '''
 1189         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
 1190    '''
 1191    __slots__ = [
 1192        'account_attachment',
 1193        'meta',
 1194        'rate_limit',
 1195    ]
 1196
 1197    def __init__(
 1198        self,
 1199        account_attachment=None,
 1200        meta=None,
 1201        rate_limit=None,
 1202    ):
 1203        self.account_attachment = account_attachment if account_attachment is not None else None
 1204        '''
 1205         The created AccountAttachment.
 1206        '''
 1207        self.meta = meta if meta is not None else None
 1208        '''
 1209         Reserved for future use.
 1210        '''
 1211        self.rate_limit = rate_limit if rate_limit is not None else None
 1212        '''
 1213         Rate limit information.
 1214        '''
 1215
 1216    def __repr__(self):
 1217        return '<sdm.AccountAttachmentCreateResponse ' + \
 1218            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1219            'meta: ' + repr(self.meta) + ' ' +\
 1220            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1221            '>'
 1222
 1223    def to_dict(self):
 1224        return {
 1225            'account_attachment': self.account_attachment,
 1226            'meta': self.meta,
 1227            'rate_limit': self.rate_limit,
 1228        }
 1229
 1230    @classmethod
 1231    def from_dict(cls, d):
 1232        return cls(
 1233            account_attachment=d.get('account_attachment'),
 1234            meta=d.get('meta'),
 1235            rate_limit=d.get('rate_limit'),
 1236        )
 1237
 1238
 1239class AccountAttachmentDeleteResponse:
 1240    '''
 1241         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
 1242    '''
 1243    __slots__ = [
 1244        'meta',
 1245        'rate_limit',
 1246    ]
 1247
 1248    def __init__(
 1249        self,
 1250        meta=None,
 1251        rate_limit=None,
 1252    ):
 1253        self.meta = meta if meta is not None else None
 1254        '''
 1255         Reserved for future use.
 1256        '''
 1257        self.rate_limit = rate_limit if rate_limit is not None else None
 1258        '''
 1259         Rate limit information.
 1260        '''
 1261
 1262    def __repr__(self):
 1263        return '<sdm.AccountAttachmentDeleteResponse ' + \
 1264            'meta: ' + repr(self.meta) + ' ' +\
 1265            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1266            '>'
 1267
 1268    def to_dict(self):
 1269        return {
 1270            'meta': self.meta,
 1271            'rate_limit': self.rate_limit,
 1272        }
 1273
 1274    @classmethod
 1275    def from_dict(cls, d):
 1276        return cls(
 1277            meta=d.get('meta'),
 1278            rate_limit=d.get('rate_limit'),
 1279        )
 1280
 1281
 1282class AccountAttachmentGetResponse:
 1283    '''
 1284         AccountAttachmentGetResponse returns a requested AccountAttachment.
 1285    '''
 1286    __slots__ = [
 1287        'account_attachment',
 1288        'meta',
 1289        'rate_limit',
 1290    ]
 1291
 1292    def __init__(
 1293        self,
 1294        account_attachment=None,
 1295        meta=None,
 1296        rate_limit=None,
 1297    ):
 1298        self.account_attachment = account_attachment if account_attachment is not None else None
 1299        '''
 1300         The requested AccountAttachment.
 1301        '''
 1302        self.meta = meta if meta is not None else None
 1303        '''
 1304         Reserved for future use.
 1305        '''
 1306        self.rate_limit = rate_limit if rate_limit is not None else None
 1307        '''
 1308         Rate limit information.
 1309        '''
 1310
 1311    def __repr__(self):
 1312        return '<sdm.AccountAttachmentGetResponse ' + \
 1313            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1314            'meta: ' + repr(self.meta) + ' ' +\
 1315            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1316            '>'
 1317
 1318    def to_dict(self):
 1319        return {
 1320            'account_attachment': self.account_attachment,
 1321            'meta': self.meta,
 1322            'rate_limit': self.rate_limit,
 1323        }
 1324
 1325    @classmethod
 1326    def from_dict(cls, d):
 1327        return cls(
 1328            account_attachment=d.get('account_attachment'),
 1329            meta=d.get('meta'),
 1330            rate_limit=d.get('rate_limit'),
 1331        )
 1332
 1333
 1334class AccountCreateResponse:
 1335    '''
 1336         AccountCreateResponse reports how the Accounts were created in the system.
 1337    '''
 1338    __slots__ = [
 1339        'account',
 1340        'meta',
 1341        'rate_limit',
 1342        'token',
 1343    ]
 1344
 1345    def __init__(
 1346        self,
 1347        account=None,
 1348        meta=None,
 1349        rate_limit=None,
 1350        token=None,
 1351    ):
 1352        self.account = account if account is not None else None
 1353        '''
 1354         The created Account.
 1355        '''
 1356        self.meta = meta if meta is not None else None
 1357        '''
 1358         Reserved for future use.
 1359        '''
 1360        self.rate_limit = rate_limit if rate_limit is not None else None
 1361        '''
 1362         Rate limit information.
 1363        '''
 1364        self.token = token if token is not None else ''
 1365        '''
 1366         The auth token generated for the Account. The Account will use this token to
 1367         authenticate with the strongDM API.
 1368        '''
 1369
 1370    def __repr__(self):
 1371        return '<sdm.AccountCreateResponse ' + \
 1372            'account: ' + repr(self.account) + ' ' +\
 1373            'meta: ' + repr(self.meta) + ' ' +\
 1374            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1375            'token: ' + repr(self.token) + ' ' +\
 1376            '>'
 1377
 1378    def to_dict(self):
 1379        return {
 1380            'account': self.account,
 1381            'meta': self.meta,
 1382            'rate_limit': self.rate_limit,
 1383            'token': self.token,
 1384        }
 1385
 1386    @classmethod
 1387    def from_dict(cls, d):
 1388        return cls(
 1389            account=d.get('account'),
 1390            meta=d.get('meta'),
 1391            rate_limit=d.get('rate_limit'),
 1392            token=d.get('token'),
 1393        )
 1394
 1395
 1396class AccountDeleteResponse:
 1397    '''
 1398         AccountDeleteResponse returns information about a Account that was deleted.
 1399    '''
 1400    __slots__ = [
 1401        'meta',
 1402        'rate_limit',
 1403    ]
 1404
 1405    def __init__(
 1406        self,
 1407        meta=None,
 1408        rate_limit=None,
 1409    ):
 1410        self.meta = meta if meta is not None else None
 1411        '''
 1412         Reserved for future use.
 1413        '''
 1414        self.rate_limit = rate_limit if rate_limit is not None else None
 1415        '''
 1416         Rate limit information.
 1417        '''
 1418
 1419    def __repr__(self):
 1420        return '<sdm.AccountDeleteResponse ' + \
 1421            'meta: ' + repr(self.meta) + ' ' +\
 1422            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1423            '>'
 1424
 1425    def to_dict(self):
 1426        return {
 1427            'meta': self.meta,
 1428            'rate_limit': self.rate_limit,
 1429        }
 1430
 1431    @classmethod
 1432    def from_dict(cls, d):
 1433        return cls(
 1434            meta=d.get('meta'),
 1435            rate_limit=d.get('rate_limit'),
 1436        )
 1437
 1438
 1439class AccountGetResponse:
 1440    '''
 1441         AccountGetResponse returns a requested Account.
 1442    '''
 1443    __slots__ = [
 1444        'account',
 1445        'meta',
 1446        'rate_limit',
 1447    ]
 1448
 1449    def __init__(
 1450        self,
 1451        account=None,
 1452        meta=None,
 1453        rate_limit=None,
 1454    ):
 1455        self.account = account if account is not None else None
 1456        '''
 1457         The requested Account.
 1458        '''
 1459        self.meta = meta if meta is not None else None
 1460        '''
 1461         Reserved for future use.
 1462        '''
 1463        self.rate_limit = rate_limit if rate_limit is not None else None
 1464        '''
 1465         Rate limit information.
 1466        '''
 1467
 1468    def __repr__(self):
 1469        return '<sdm.AccountGetResponse ' + \
 1470            'account: ' + repr(self.account) + ' ' +\
 1471            'meta: ' + repr(self.meta) + ' ' +\
 1472            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1473            '>'
 1474
 1475    def to_dict(self):
 1476        return {
 1477            'account': self.account,
 1478            'meta': self.meta,
 1479            'rate_limit': self.rate_limit,
 1480        }
 1481
 1482    @classmethod
 1483    def from_dict(cls, d):
 1484        return cls(
 1485            account=d.get('account'),
 1486            meta=d.get('meta'),
 1487            rate_limit=d.get('rate_limit'),
 1488        )
 1489
 1490
 1491class AccountGrant:
 1492    '''
 1493         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1494    '''
 1495    __slots__ = [
 1496        'account_id',
 1497        'id',
 1498        'resource_id',
 1499        'start_from',
 1500        'valid_until',
 1501    ]
 1502
 1503    def __init__(
 1504        self,
 1505        account_id=None,
 1506        id=None,
 1507        resource_id=None,
 1508        start_from=None,
 1509        valid_until=None,
 1510    ):
 1511        self.account_id = account_id if account_id is not None else ''
 1512        '''
 1513         The account ID of this AccountGrant.
 1514        '''
 1515        self.id = id if id is not None else ''
 1516        '''
 1517         Unique identifier of the AccountGrant.
 1518        '''
 1519        self.resource_id = resource_id if resource_id is not None else ''
 1520        '''
 1521         The resource ID of this AccountGrant.
 1522        '''
 1523        self.start_from = start_from if start_from is not None else None
 1524        '''
 1525         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
 1526        '''
 1527        self.valid_until = valid_until if valid_until is not None else None
 1528        '''
 1529         The timestamp when the resource grant will expire.
 1530        '''
 1531
 1532    def __repr__(self):
 1533        return '<sdm.AccountGrant ' + \
 1534            'account_id: ' + repr(self.account_id) + ' ' +\
 1535            'id: ' + repr(self.id) + ' ' +\
 1536            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1537            'start_from: ' + repr(self.start_from) + ' ' +\
 1538            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1539            '>'
 1540
 1541    def to_dict(self):
 1542        return {
 1543            'account_id': self.account_id,
 1544            'id': self.id,
 1545            'resource_id': self.resource_id,
 1546            'start_from': self.start_from,
 1547            'valid_until': self.valid_until,
 1548        }
 1549
 1550    @classmethod
 1551    def from_dict(cls, d):
 1552        return cls(
 1553            account_id=d.get('account_id'),
 1554            id=d.get('id'),
 1555            resource_id=d.get('resource_id'),
 1556            start_from=d.get('start_from'),
 1557            valid_until=d.get('valid_until'),
 1558        )
 1559
 1560
 1561class AccountGrantCreateResponse:
 1562    '''
 1563         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1564    '''
 1565    __slots__ = [
 1566        'account_grant',
 1567        'meta',
 1568        'rate_limit',
 1569    ]
 1570
 1571    def __init__(
 1572        self,
 1573        account_grant=None,
 1574        meta=None,
 1575        rate_limit=None,
 1576    ):
 1577        self.account_grant = account_grant if account_grant is not None else None
 1578        '''
 1579         The created AccountGrant.
 1580        '''
 1581        self.meta = meta if meta is not None else None
 1582        '''
 1583         Reserved for future use.
 1584        '''
 1585        self.rate_limit = rate_limit if rate_limit is not None else None
 1586        '''
 1587         Rate limit information.
 1588        '''
 1589
 1590    def __repr__(self):
 1591        return '<sdm.AccountGrantCreateResponse ' + \
 1592            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1593            'meta: ' + repr(self.meta) + ' ' +\
 1594            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1595            '>'
 1596
 1597    def to_dict(self):
 1598        return {
 1599            'account_grant': self.account_grant,
 1600            'meta': self.meta,
 1601            'rate_limit': self.rate_limit,
 1602        }
 1603
 1604    @classmethod
 1605    def from_dict(cls, d):
 1606        return cls(
 1607            account_grant=d.get('account_grant'),
 1608            meta=d.get('meta'),
 1609            rate_limit=d.get('rate_limit'),
 1610        )
 1611
 1612
 1613class AccountGrantDeleteResponse:
 1614    '''
 1615         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1616    '''
 1617    __slots__ = [
 1618        'meta',
 1619        'rate_limit',
 1620    ]
 1621
 1622    def __init__(
 1623        self,
 1624        meta=None,
 1625        rate_limit=None,
 1626    ):
 1627        self.meta = meta if meta is not None else None
 1628        '''
 1629         Reserved for future use.
 1630        '''
 1631        self.rate_limit = rate_limit if rate_limit is not None else None
 1632        '''
 1633         Rate limit information.
 1634        '''
 1635
 1636    def __repr__(self):
 1637        return '<sdm.AccountGrantDeleteResponse ' + \
 1638            'meta: ' + repr(self.meta) + ' ' +\
 1639            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1640            '>'
 1641
 1642    def to_dict(self):
 1643        return {
 1644            'meta': self.meta,
 1645            'rate_limit': self.rate_limit,
 1646        }
 1647
 1648    @classmethod
 1649    def from_dict(cls, d):
 1650        return cls(
 1651            meta=d.get('meta'),
 1652            rate_limit=d.get('rate_limit'),
 1653        )
 1654
 1655
 1656class AccountGrantGetResponse:
 1657    '''
 1658         AccountGrantGetResponse returns a requested AccountGrant.
 1659    '''
 1660    __slots__ = [
 1661        'account_grant',
 1662        'meta',
 1663        'rate_limit',
 1664    ]
 1665
 1666    def __init__(
 1667        self,
 1668        account_grant=None,
 1669        meta=None,
 1670        rate_limit=None,
 1671    ):
 1672        self.account_grant = account_grant if account_grant is not None else None
 1673        '''
 1674         The requested AccountGrant.
 1675        '''
 1676        self.meta = meta if meta is not None else None
 1677        '''
 1678         Reserved for future use.
 1679        '''
 1680        self.rate_limit = rate_limit if rate_limit is not None else None
 1681        '''
 1682         Rate limit information.
 1683        '''
 1684
 1685    def __repr__(self):
 1686        return '<sdm.AccountGrantGetResponse ' + \
 1687            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1688            'meta: ' + repr(self.meta) + ' ' +\
 1689            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1690            '>'
 1691
 1692    def to_dict(self):
 1693        return {
 1694            'account_grant': self.account_grant,
 1695            'meta': self.meta,
 1696            'rate_limit': self.rate_limit,
 1697        }
 1698
 1699    @classmethod
 1700    def from_dict(cls, d):
 1701        return cls(
 1702            account_grant=d.get('account_grant'),
 1703            meta=d.get('meta'),
 1704            rate_limit=d.get('rate_limit'),
 1705        )
 1706
 1707
 1708class AccountUpdateResponse:
 1709    '''
 1710         AccountUpdateResponse returns the fields of a Account after it has been updated by
 1711     a AccountUpdateRequest.
 1712    '''
 1713    __slots__ = [
 1714        'account',
 1715        'meta',
 1716        'rate_limit',
 1717    ]
 1718
 1719    def __init__(
 1720        self,
 1721        account=None,
 1722        meta=None,
 1723        rate_limit=None,
 1724    ):
 1725        self.account = account if account is not None else None
 1726        '''
 1727         The updated Account.
 1728        '''
 1729        self.meta = meta if meta is not None else None
 1730        '''
 1731         Reserved for future use.
 1732        '''
 1733        self.rate_limit = rate_limit if rate_limit is not None else None
 1734        '''
 1735         Rate limit information.
 1736        '''
 1737
 1738    def __repr__(self):
 1739        return '<sdm.AccountUpdateResponse ' + \
 1740            'account: ' + repr(self.account) + ' ' +\
 1741            'meta: ' + repr(self.meta) + ' ' +\
 1742            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1743            '>'
 1744
 1745    def to_dict(self):
 1746        return {
 1747            'account': self.account,
 1748            'meta': self.meta,
 1749            'rate_limit': self.rate_limit,
 1750        }
 1751
 1752    @classmethod
 1753    def from_dict(cls, d):
 1754        return cls(
 1755            account=d.get('account'),
 1756            meta=d.get('meta'),
 1757            rate_limit=d.get('rate_limit'),
 1758        )
 1759
 1760
 1761class AmazonEKS:
 1762    __slots__ = [
 1763        'access_key',
 1764        'bind_interface',
 1765        'certificate_authority',
 1766        'cluster_name',
 1767        'egress_filter',
 1768        'endpoint',
 1769        'healthcheck_namespace',
 1770        'healthy',
 1771        'id',
 1772        'name',
 1773        'region',
 1774        'remote_identity_group_id',
 1775        'remote_identity_healthcheck_username',
 1776        'role_arn',
 1777        'role_external_id',
 1778        'secret_access_key',
 1779        'secret_store_id',
 1780        'tags',
 1781    ]
 1782
 1783    def __init__(
 1784        self,
 1785        access_key=None,
 1786        bind_interface=None,
 1787        certificate_authority=None,
 1788        cluster_name=None,
 1789        egress_filter=None,
 1790        endpoint=None,
 1791        healthcheck_namespace=None,
 1792        healthy=None,
 1793        id=None,
 1794        name=None,
 1795        region=None,
 1796        remote_identity_group_id=None,
 1797        remote_identity_healthcheck_username=None,
 1798        role_arn=None,
 1799        role_external_id=None,
 1800        secret_access_key=None,
 1801        secret_store_id=None,
 1802        tags=None,
 1803    ):
 1804        self.access_key = access_key if access_key is not None else ''
 1805        self.bind_interface = bind_interface if bind_interface is not None else ''
 1806        '''
 1807         Bind interface
 1808        '''
 1809        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1810        self.cluster_name = cluster_name if cluster_name is not None else ''
 1811        self.egress_filter = egress_filter if egress_filter is not None else ''
 1812        '''
 1813         A filter applied to the routing logic to pin datasource to nodes.
 1814        '''
 1815        self.endpoint = endpoint if endpoint is not None else ''
 1816        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1817        '''
 1818         The path used to check the health of your connection.  Defaults to `default`.
 1819        '''
 1820        self.healthy = healthy if healthy is not None else False
 1821        '''
 1822         True if the datasource is reachable and the credentials are valid.
 1823        '''
 1824        self.id = id if id is not None else ''
 1825        '''
 1826         Unique identifier of the Resource.
 1827        '''
 1828        self.name = name if name is not None else ''
 1829        '''
 1830         Unique human-readable name of the Resource.
 1831        '''
 1832        self.region = region if region is not None else ''
 1833        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1834        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1835        self.role_arn = role_arn if role_arn is not None else ''
 1836        self.role_external_id = role_external_id if role_external_id is not None else ''
 1837        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1838        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1839        '''
 1840         ID of the secret store containing credentials for this resource, if any.
 1841        '''
 1842        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1843        '''
 1844         Tags is a map of key, value pairs.
 1845        '''
 1846
 1847    def __repr__(self):
 1848        return '<sdm.AmazonEKS ' + \
 1849            'access_key: ' + repr(self.access_key) + ' ' +\
 1850            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1851            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1852            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1853            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1854            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1855            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1856            'healthy: ' + repr(self.healthy) + ' ' +\
 1857            'id: ' + repr(self.id) + ' ' +\
 1858            'name: ' + repr(self.name) + ' ' +\
 1859            'region: ' + repr(self.region) + ' ' +\
 1860            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1861            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1862            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1863            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1864            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1865            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1866            'tags: ' + repr(self.tags) + ' ' +\
 1867            '>'
 1868
 1869    def to_dict(self):
 1870        return {
 1871            'access_key': self.access_key,
 1872            'bind_interface': self.bind_interface,
 1873            'certificate_authority': self.certificate_authority,
 1874            'cluster_name': self.cluster_name,
 1875            'egress_filter': self.egress_filter,
 1876            'endpoint': self.endpoint,
 1877            'healthcheck_namespace': self.healthcheck_namespace,
 1878            'healthy': self.healthy,
 1879            'id': self.id,
 1880            'name': self.name,
 1881            'region': self.region,
 1882            'remote_identity_group_id': self.remote_identity_group_id,
 1883            'remote_identity_healthcheck_username':
 1884            self.remote_identity_healthcheck_username,
 1885            'role_arn': self.role_arn,
 1886            'role_external_id': self.role_external_id,
 1887            'secret_access_key': self.secret_access_key,
 1888            'secret_store_id': self.secret_store_id,
 1889            'tags': self.tags,
 1890        }
 1891
 1892    @classmethod
 1893    def from_dict(cls, d):
 1894        return cls(
 1895            access_key=d.get('access_key'),
 1896            bind_interface=d.get('bind_interface'),
 1897            certificate_authority=d.get('certificate_authority'),
 1898            cluster_name=d.get('cluster_name'),
 1899            egress_filter=d.get('egress_filter'),
 1900            endpoint=d.get('endpoint'),
 1901            healthcheck_namespace=d.get('healthcheck_namespace'),
 1902            healthy=d.get('healthy'),
 1903            id=d.get('id'),
 1904            name=d.get('name'),
 1905            region=d.get('region'),
 1906            remote_identity_group_id=d.get('remote_identity_group_id'),
 1907            remote_identity_healthcheck_username=d.get(
 1908                'remote_identity_healthcheck_username'),
 1909            role_arn=d.get('role_arn'),
 1910            role_external_id=d.get('role_external_id'),
 1911            secret_access_key=d.get('secret_access_key'),
 1912            secret_store_id=d.get('secret_store_id'),
 1913            tags=d.get('tags'),
 1914        )
 1915
 1916
 1917class AmazonEKSUserImpersonation:
 1918    __slots__ = [
 1919        'access_key',
 1920        'bind_interface',
 1921        'certificate_authority',
 1922        'cluster_name',
 1923        'egress_filter',
 1924        'endpoint',
 1925        'healthcheck_namespace',
 1926        'healthy',
 1927        'id',
 1928        'name',
 1929        'region',
 1930        'role_arn',
 1931        'role_external_id',
 1932        'secret_access_key',
 1933        'secret_store_id',
 1934        'tags',
 1935    ]
 1936
 1937    def __init__(
 1938        self,
 1939        access_key=None,
 1940        bind_interface=None,
 1941        certificate_authority=None,
 1942        cluster_name=None,
 1943        egress_filter=None,
 1944        endpoint=None,
 1945        healthcheck_namespace=None,
 1946        healthy=None,
 1947        id=None,
 1948        name=None,
 1949        region=None,
 1950        role_arn=None,
 1951        role_external_id=None,
 1952        secret_access_key=None,
 1953        secret_store_id=None,
 1954        tags=None,
 1955    ):
 1956        self.access_key = access_key if access_key is not None else ''
 1957        self.bind_interface = bind_interface if bind_interface is not None else ''
 1958        '''
 1959         Bind interface
 1960        '''
 1961        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1962        self.cluster_name = cluster_name if cluster_name is not None else ''
 1963        self.egress_filter = egress_filter if egress_filter is not None else ''
 1964        '''
 1965         A filter applied to the routing logic to pin datasource to nodes.
 1966        '''
 1967        self.endpoint = endpoint if endpoint is not None else ''
 1968        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1969        '''
 1970         The path used to check the health of your connection.  Defaults to `default`.
 1971        '''
 1972        self.healthy = healthy if healthy is not None else False
 1973        '''
 1974         True if the datasource is reachable and the credentials are valid.
 1975        '''
 1976        self.id = id if id is not None else ''
 1977        '''
 1978         Unique identifier of the Resource.
 1979        '''
 1980        self.name = name if name is not None else ''
 1981        '''
 1982         Unique human-readable name of the Resource.
 1983        '''
 1984        self.region = region if region is not None else ''
 1985        self.role_arn = role_arn if role_arn is not None else ''
 1986        self.role_external_id = role_external_id if role_external_id is not None else ''
 1987        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1988        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1989        '''
 1990         ID of the secret store containing credentials for this resource, if any.
 1991        '''
 1992        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1993        '''
 1994         Tags is a map of key, value pairs.
 1995        '''
 1996
 1997    def __repr__(self):
 1998        return '<sdm.AmazonEKSUserImpersonation ' + \
 1999            'access_key: ' + repr(self.access_key) + ' ' +\
 2000            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2001            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 2002            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 2003            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2004            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2005            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 2006            'healthy: ' + repr(self.healthy) + ' ' +\
 2007            'id: ' + repr(self.id) + ' ' +\
 2008            'name: ' + repr(self.name) + ' ' +\
 2009            'region: ' + repr(self.region) + ' ' +\
 2010            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2011            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2012            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2013            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2014            'tags: ' + repr(self.tags) + ' ' +\
 2015            '>'
 2016
 2017    def to_dict(self):
 2018        return {
 2019            'access_key': self.access_key,
 2020            'bind_interface': self.bind_interface,
 2021            'certificate_authority': self.certificate_authority,
 2022            'cluster_name': self.cluster_name,
 2023            'egress_filter': self.egress_filter,
 2024            'endpoint': self.endpoint,
 2025            'healthcheck_namespace': self.healthcheck_namespace,
 2026            'healthy': self.healthy,
 2027            'id': self.id,
 2028            'name': self.name,
 2029            'region': self.region,
 2030            'role_arn': self.role_arn,
 2031            'role_external_id': self.role_external_id,
 2032            'secret_access_key': self.secret_access_key,
 2033            'secret_store_id': self.secret_store_id,
 2034            'tags': self.tags,
 2035        }
 2036
 2037    @classmethod
 2038    def from_dict(cls, d):
 2039        return cls(
 2040            access_key=d.get('access_key'),
 2041            bind_interface=d.get('bind_interface'),
 2042            certificate_authority=d.get('certificate_authority'),
 2043            cluster_name=d.get('cluster_name'),
 2044            egress_filter=d.get('egress_filter'),
 2045            endpoint=d.get('endpoint'),
 2046            healthcheck_namespace=d.get('healthcheck_namespace'),
 2047            healthy=d.get('healthy'),
 2048            id=d.get('id'),
 2049            name=d.get('name'),
 2050            region=d.get('region'),
 2051            role_arn=d.get('role_arn'),
 2052            role_external_id=d.get('role_external_id'),
 2053            secret_access_key=d.get('secret_access_key'),
 2054            secret_store_id=d.get('secret_store_id'),
 2055            tags=d.get('tags'),
 2056        )
 2057
 2058
 2059class AmazonES:
 2060    __slots__ = [
 2061        'access_key',
 2062        'bind_interface',
 2063        'egress_filter',
 2064        'endpoint',
 2065        'healthy',
 2066        'id',
 2067        'name',
 2068        'port_override',
 2069        'region',
 2070        'role_arn',
 2071        'role_external_id',
 2072        'secret_access_key',
 2073        'secret_store_id',
 2074        'tags',
 2075    ]
 2076
 2077    def __init__(
 2078        self,
 2079        access_key=None,
 2080        bind_interface=None,
 2081        egress_filter=None,
 2082        endpoint=None,
 2083        healthy=None,
 2084        id=None,
 2085        name=None,
 2086        port_override=None,
 2087        region=None,
 2088        role_arn=None,
 2089        role_external_id=None,
 2090        secret_access_key=None,
 2091        secret_store_id=None,
 2092        tags=None,
 2093    ):
 2094        self.access_key = access_key if access_key is not None else ''
 2095        self.bind_interface = bind_interface if bind_interface is not None else ''
 2096        '''
 2097         Bind interface
 2098        '''
 2099        self.egress_filter = egress_filter if egress_filter is not None else ''
 2100        '''
 2101         A filter applied to the routing logic to pin datasource to nodes.
 2102        '''
 2103        self.endpoint = endpoint if endpoint is not None else ''
 2104        self.healthy = healthy if healthy is not None else False
 2105        '''
 2106         True if the datasource is reachable and the credentials are valid.
 2107        '''
 2108        self.id = id if id is not None else ''
 2109        '''
 2110         Unique identifier of the Resource.
 2111        '''
 2112        self.name = name if name is not None else ''
 2113        '''
 2114         Unique human-readable name of the Resource.
 2115        '''
 2116        self.port_override = port_override if port_override is not None else 0
 2117        self.region = region if region is not None else ''
 2118        self.role_arn = role_arn if role_arn is not None else ''
 2119        self.role_external_id = role_external_id if role_external_id is not None else ''
 2120        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2121        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2122        '''
 2123         ID of the secret store containing credentials for this resource, if any.
 2124        '''
 2125        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2126        '''
 2127         Tags is a map of key, value pairs.
 2128        '''
 2129
 2130    def __repr__(self):
 2131        return '<sdm.AmazonES ' + \
 2132            'access_key: ' + repr(self.access_key) + ' ' +\
 2133            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2134            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2135            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2136            'healthy: ' + repr(self.healthy) + ' ' +\
 2137            'id: ' + repr(self.id) + ' ' +\
 2138            'name: ' + repr(self.name) + ' ' +\
 2139            'port_override: ' + repr(self.port_override) + ' ' +\
 2140            'region: ' + repr(self.region) + ' ' +\
 2141            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2142            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2143            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2144            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2145            'tags: ' + repr(self.tags) + ' ' +\
 2146            '>'
 2147
 2148    def to_dict(self):
 2149        return {
 2150            'access_key': self.access_key,
 2151            'bind_interface': self.bind_interface,
 2152            'egress_filter': self.egress_filter,
 2153            'endpoint': self.endpoint,
 2154            'healthy': self.healthy,
 2155            'id': self.id,
 2156            'name': self.name,
 2157            'port_override': self.port_override,
 2158            'region': self.region,
 2159            'role_arn': self.role_arn,
 2160            'role_external_id': self.role_external_id,
 2161            'secret_access_key': self.secret_access_key,
 2162            'secret_store_id': self.secret_store_id,
 2163            'tags': self.tags,
 2164        }
 2165
 2166    @classmethod
 2167    def from_dict(cls, d):
 2168        return cls(
 2169            access_key=d.get('access_key'),
 2170            bind_interface=d.get('bind_interface'),
 2171            egress_filter=d.get('egress_filter'),
 2172            endpoint=d.get('endpoint'),
 2173            healthy=d.get('healthy'),
 2174            id=d.get('id'),
 2175            name=d.get('name'),
 2176            port_override=d.get('port_override'),
 2177            region=d.get('region'),
 2178            role_arn=d.get('role_arn'),
 2179            role_external_id=d.get('role_external_id'),
 2180            secret_access_key=d.get('secret_access_key'),
 2181            secret_store_id=d.get('secret_store_id'),
 2182            tags=d.get('tags'),
 2183        )
 2184
 2185
 2186class AmazonMQAMQP091:
 2187    __slots__ = [
 2188        'bind_interface',
 2189        'egress_filter',
 2190        'healthy',
 2191        'hostname',
 2192        'id',
 2193        'name',
 2194        'password',
 2195        'port',
 2196        'port_override',
 2197        'secret_store_id',
 2198        'tags',
 2199        'tls_required',
 2200        'username',
 2201    ]
 2202
 2203    def __init__(
 2204        self,
 2205        bind_interface=None,
 2206        egress_filter=None,
 2207        healthy=None,
 2208        hostname=None,
 2209        id=None,
 2210        name=None,
 2211        password=None,
 2212        port=None,
 2213        port_override=None,
 2214        secret_store_id=None,
 2215        tags=None,
 2216        tls_required=None,
 2217        username=None,
 2218    ):
 2219        self.bind_interface = bind_interface if bind_interface is not None else ''
 2220        '''
 2221         Bind interface
 2222        '''
 2223        self.egress_filter = egress_filter if egress_filter is not None else ''
 2224        '''
 2225         A filter applied to the routing logic to pin datasource to nodes.
 2226        '''
 2227        self.healthy = healthy if healthy is not None else False
 2228        '''
 2229         True if the datasource is reachable and the credentials are valid.
 2230        '''
 2231        self.hostname = hostname if hostname is not None else ''
 2232        self.id = id if id is not None else ''
 2233        '''
 2234         Unique identifier of the Resource.
 2235        '''
 2236        self.name = name if name is not None else ''
 2237        '''
 2238         Unique human-readable name of the Resource.
 2239        '''
 2240        self.password = password if password is not None else ''
 2241        self.port = port if port is not None else 0
 2242        self.port_override = port_override if port_override is not None else 0
 2243        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2244        '''
 2245         ID of the secret store containing credentials for this resource, if any.
 2246        '''
 2247        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2248        '''
 2249         Tags is a map of key, value pairs.
 2250        '''
 2251        self.tls_required = tls_required if tls_required is not None else False
 2252        self.username = username if username is not None else ''
 2253
 2254    def __repr__(self):
 2255        return '<sdm.AmazonMQAMQP091 ' + \
 2256            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2257            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2258            'healthy: ' + repr(self.healthy) + ' ' +\
 2259            'hostname: ' + repr(self.hostname) + ' ' +\
 2260            'id: ' + repr(self.id) + ' ' +\
 2261            'name: ' + repr(self.name) + ' ' +\
 2262            'password: ' + repr(self.password) + ' ' +\
 2263            'port: ' + repr(self.port) + ' ' +\
 2264            'port_override: ' + repr(self.port_override) + ' ' +\
 2265            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2266            'tags: ' + repr(self.tags) + ' ' +\
 2267            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2268            'username: ' + repr(self.username) + ' ' +\
 2269            '>'
 2270
 2271    def to_dict(self):
 2272        return {
 2273            'bind_interface': self.bind_interface,
 2274            'egress_filter': self.egress_filter,
 2275            'healthy': self.healthy,
 2276            'hostname': self.hostname,
 2277            'id': self.id,
 2278            'name': self.name,
 2279            'password': self.password,
 2280            'port': self.port,
 2281            'port_override': self.port_override,
 2282            'secret_store_id': self.secret_store_id,
 2283            'tags': self.tags,
 2284            'tls_required': self.tls_required,
 2285            'username': self.username,
 2286        }
 2287
 2288    @classmethod
 2289    def from_dict(cls, d):
 2290        return cls(
 2291            bind_interface=d.get('bind_interface'),
 2292            egress_filter=d.get('egress_filter'),
 2293            healthy=d.get('healthy'),
 2294            hostname=d.get('hostname'),
 2295            id=d.get('id'),
 2296            name=d.get('name'),
 2297            password=d.get('password'),
 2298            port=d.get('port'),
 2299            port_override=d.get('port_override'),
 2300            secret_store_id=d.get('secret_store_id'),
 2301            tags=d.get('tags'),
 2302            tls_required=d.get('tls_required'),
 2303            username=d.get('username'),
 2304        )
 2305
 2306
 2307class Athena:
 2308    __slots__ = [
 2309        'access_key',
 2310        'bind_interface',
 2311        'egress_filter',
 2312        'healthy',
 2313        'id',
 2314        'name',
 2315        'output',
 2316        'port_override',
 2317        'region',
 2318        'role_arn',
 2319        'role_external_id',
 2320        'secret_access_key',
 2321        'secret_store_id',
 2322        'tags',
 2323    ]
 2324
 2325    def __init__(
 2326        self,
 2327        access_key=None,
 2328        bind_interface=None,
 2329        egress_filter=None,
 2330        healthy=None,
 2331        id=None,
 2332        name=None,
 2333        output=None,
 2334        port_override=None,
 2335        region=None,
 2336        role_arn=None,
 2337        role_external_id=None,
 2338        secret_access_key=None,
 2339        secret_store_id=None,
 2340        tags=None,
 2341    ):
 2342        self.access_key = access_key if access_key is not None else ''
 2343        self.bind_interface = bind_interface if bind_interface is not None else ''
 2344        '''
 2345         Bind interface
 2346        '''
 2347        self.egress_filter = egress_filter if egress_filter is not None else ''
 2348        '''
 2349         A filter applied to the routing logic to pin datasource to nodes.
 2350        '''
 2351        self.healthy = healthy if healthy is not None else False
 2352        '''
 2353         True if the datasource is reachable and the credentials are valid.
 2354        '''
 2355        self.id = id if id is not None else ''
 2356        '''
 2357         Unique identifier of the Resource.
 2358        '''
 2359        self.name = name if name is not None else ''
 2360        '''
 2361         Unique human-readable name of the Resource.
 2362        '''
 2363        self.output = output if output is not None else ''
 2364        self.port_override = port_override if port_override is not None else 0
 2365        self.region = region if region is not None else ''
 2366        self.role_arn = role_arn if role_arn is not None else ''
 2367        self.role_external_id = role_external_id if role_external_id is not None else ''
 2368        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2369        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2370        '''
 2371         ID of the secret store containing credentials for this resource, if any.
 2372        '''
 2373        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2374        '''
 2375         Tags is a map of key, value pairs.
 2376        '''
 2377
 2378    def __repr__(self):
 2379        return '<sdm.Athena ' + \
 2380            'access_key: ' + repr(self.access_key) + ' ' +\
 2381            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2382            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2383            'healthy: ' + repr(self.healthy) + ' ' +\
 2384            'id: ' + repr(self.id) + ' ' +\
 2385            'name: ' + repr(self.name) + ' ' +\
 2386            'output: ' + repr(self.output) + ' ' +\
 2387            'port_override: ' + repr(self.port_override) + ' ' +\
 2388            'region: ' + repr(self.region) + ' ' +\
 2389            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2390            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2391            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2392            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2393            'tags: ' + repr(self.tags) + ' ' +\
 2394            '>'
 2395
 2396    def to_dict(self):
 2397        return {
 2398            'access_key': self.access_key,
 2399            'bind_interface': self.bind_interface,
 2400            'egress_filter': self.egress_filter,
 2401            'healthy': self.healthy,
 2402            'id': self.id,
 2403            'name': self.name,
 2404            'output': self.output,
 2405            'port_override': self.port_override,
 2406            'region': self.region,
 2407            'role_arn': self.role_arn,
 2408            'role_external_id': self.role_external_id,
 2409            'secret_access_key': self.secret_access_key,
 2410            'secret_store_id': self.secret_store_id,
 2411            'tags': self.tags,
 2412        }
 2413
 2414    @classmethod
 2415    def from_dict(cls, d):
 2416        return cls(
 2417            access_key=d.get('access_key'),
 2418            bind_interface=d.get('bind_interface'),
 2419            egress_filter=d.get('egress_filter'),
 2420            healthy=d.get('healthy'),
 2421            id=d.get('id'),
 2422            name=d.get('name'),
 2423            output=d.get('output'),
 2424            port_override=d.get('port_override'),
 2425            region=d.get('region'),
 2426            role_arn=d.get('role_arn'),
 2427            role_external_id=d.get('role_external_id'),
 2428            secret_access_key=d.get('secret_access_key'),
 2429            secret_store_id=d.get('secret_store_id'),
 2430            tags=d.get('tags'),
 2431        )
 2432
 2433
 2434class AuroraMysql:
 2435    __slots__ = [
 2436        'bind_interface',
 2437        'database',
 2438        'egress_filter',
 2439        'healthy',
 2440        'hostname',
 2441        'id',
 2442        'name',
 2443        'password',
 2444        'port',
 2445        'port_override',
 2446        'secret_store_id',
 2447        'tags',
 2448        'username',
 2449    ]
 2450
 2451    def __init__(
 2452        self,
 2453        bind_interface=None,
 2454        database=None,
 2455        egress_filter=None,
 2456        healthy=None,
 2457        hostname=None,
 2458        id=None,
 2459        name=None,
 2460        password=None,
 2461        port=None,
 2462        port_override=None,
 2463        secret_store_id=None,
 2464        tags=None,
 2465        username=None,
 2466    ):
 2467        self.bind_interface = bind_interface if bind_interface is not None else ''
 2468        '''
 2469         Bind interface
 2470        '''
 2471        self.database = database if database is not None else ''
 2472        self.egress_filter = egress_filter if egress_filter is not None else ''
 2473        '''
 2474         A filter applied to the routing logic to pin datasource to nodes.
 2475        '''
 2476        self.healthy = healthy if healthy is not None else False
 2477        '''
 2478         True if the datasource is reachable and the credentials are valid.
 2479        '''
 2480        self.hostname = hostname if hostname is not None else ''
 2481        self.id = id if id is not None else ''
 2482        '''
 2483         Unique identifier of the Resource.
 2484        '''
 2485        self.name = name if name is not None else ''
 2486        '''
 2487         Unique human-readable name of the Resource.
 2488        '''
 2489        self.password = password if password is not None else ''
 2490        self.port = port if port is not None else 0
 2491        self.port_override = port_override if port_override is not None else 0
 2492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2493        '''
 2494         ID of the secret store containing credentials for this resource, if any.
 2495        '''
 2496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2497        '''
 2498         Tags is a map of key, value pairs.
 2499        '''
 2500        self.username = username if username is not None else ''
 2501
 2502    def __repr__(self):
 2503        return '<sdm.AuroraMysql ' + \
 2504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2505            'database: ' + repr(self.database) + ' ' +\
 2506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2507            'healthy: ' + repr(self.healthy) + ' ' +\
 2508            'hostname: ' + repr(self.hostname) + ' ' +\
 2509            'id: ' + repr(self.id) + ' ' +\
 2510            'name: ' + repr(self.name) + ' ' +\
 2511            'password: ' + repr(self.password) + ' ' +\
 2512            'port: ' + repr(self.port) + ' ' +\
 2513            'port_override: ' + repr(self.port_override) + ' ' +\
 2514            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2515            'tags: ' + repr(self.tags) + ' ' +\
 2516            'username: ' + repr(self.username) + ' ' +\
 2517            '>'
 2518
 2519    def to_dict(self):
 2520        return {
 2521            'bind_interface': self.bind_interface,
 2522            'database': self.database,
 2523            'egress_filter': self.egress_filter,
 2524            'healthy': self.healthy,
 2525            'hostname': self.hostname,
 2526            'id': self.id,
 2527            'name': self.name,
 2528            'password': self.password,
 2529            'port': self.port,
 2530            'port_override': self.port_override,
 2531            'secret_store_id': self.secret_store_id,
 2532            'tags': self.tags,
 2533            'username': self.username,
 2534        }
 2535
 2536    @classmethod
 2537    def from_dict(cls, d):
 2538        return cls(
 2539            bind_interface=d.get('bind_interface'),
 2540            database=d.get('database'),
 2541            egress_filter=d.get('egress_filter'),
 2542            healthy=d.get('healthy'),
 2543            hostname=d.get('hostname'),
 2544            id=d.get('id'),
 2545            name=d.get('name'),
 2546            password=d.get('password'),
 2547            port=d.get('port'),
 2548            port_override=d.get('port_override'),
 2549            secret_store_id=d.get('secret_store_id'),
 2550            tags=d.get('tags'),
 2551            username=d.get('username'),
 2552        )
 2553
 2554
 2555class AuroraPostgres:
 2556    __slots__ = [
 2557        'bind_interface',
 2558        'database',
 2559        'egress_filter',
 2560        'healthy',
 2561        'hostname',
 2562        'id',
 2563        'name',
 2564        'override_database',
 2565        'password',
 2566        'port',
 2567        'port_override',
 2568        'secret_store_id',
 2569        'tags',
 2570        'username',
 2571    ]
 2572
 2573    def __init__(
 2574        self,
 2575        bind_interface=None,
 2576        database=None,
 2577        egress_filter=None,
 2578        healthy=None,
 2579        hostname=None,
 2580        id=None,
 2581        name=None,
 2582        override_database=None,
 2583        password=None,
 2584        port=None,
 2585        port_override=None,
 2586        secret_store_id=None,
 2587        tags=None,
 2588        username=None,
 2589    ):
 2590        self.bind_interface = bind_interface if bind_interface is not None else ''
 2591        '''
 2592         Bind interface
 2593        '''
 2594        self.database = database if database is not None else ''
 2595        self.egress_filter = egress_filter if egress_filter is not None else ''
 2596        '''
 2597         A filter applied to the routing logic to pin datasource to nodes.
 2598        '''
 2599        self.healthy = healthy if healthy is not None else False
 2600        '''
 2601         True if the datasource is reachable and the credentials are valid.
 2602        '''
 2603        self.hostname = hostname if hostname is not None else ''
 2604        self.id = id if id is not None else ''
 2605        '''
 2606         Unique identifier of the Resource.
 2607        '''
 2608        self.name = name if name is not None else ''
 2609        '''
 2610         Unique human-readable name of the Resource.
 2611        '''
 2612        self.override_database = override_database if override_database is not None else False
 2613        self.password = password if password is not None else ''
 2614        self.port = port if port is not None else 0
 2615        self.port_override = port_override if port_override is not None else 0
 2616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2617        '''
 2618         ID of the secret store containing credentials for this resource, if any.
 2619        '''
 2620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2621        '''
 2622         Tags is a map of key, value pairs.
 2623        '''
 2624        self.username = username if username is not None else ''
 2625
 2626    def __repr__(self):
 2627        return '<sdm.AuroraPostgres ' + \
 2628            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2629            'database: ' + repr(self.database) + ' ' +\
 2630            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2631            'healthy: ' + repr(self.healthy) + ' ' +\
 2632            'hostname: ' + repr(self.hostname) + ' ' +\
 2633            'id: ' + repr(self.id) + ' ' +\
 2634            'name: ' + repr(self.name) + ' ' +\
 2635            'override_database: ' + repr(self.override_database) + ' ' +\
 2636            'password: ' + repr(self.password) + ' ' +\
 2637            'port: ' + repr(self.port) + ' ' +\
 2638            'port_override: ' + repr(self.port_override) + ' ' +\
 2639            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2640            'tags: ' + repr(self.tags) + ' ' +\
 2641            'username: ' + repr(self.username) + ' ' +\
 2642            '>'
 2643
 2644    def to_dict(self):
 2645        return {
 2646            'bind_interface': self.bind_interface,
 2647            'database': self.database,
 2648            'egress_filter': self.egress_filter,
 2649            'healthy': self.healthy,
 2650            'hostname': self.hostname,
 2651            'id': self.id,
 2652            'name': self.name,
 2653            'override_database': self.override_database,
 2654            'password': self.password,
 2655            'port': self.port,
 2656            'port_override': self.port_override,
 2657            'secret_store_id': self.secret_store_id,
 2658            'tags': self.tags,
 2659            'username': self.username,
 2660        }
 2661
 2662    @classmethod
 2663    def from_dict(cls, d):
 2664        return cls(
 2665            bind_interface=d.get('bind_interface'),
 2666            database=d.get('database'),
 2667            egress_filter=d.get('egress_filter'),
 2668            healthy=d.get('healthy'),
 2669            hostname=d.get('hostname'),
 2670            id=d.get('id'),
 2671            name=d.get('name'),
 2672            override_database=d.get('override_database'),
 2673            password=d.get('password'),
 2674            port=d.get('port'),
 2675            port_override=d.get('port_override'),
 2676            secret_store_id=d.get('secret_store_id'),
 2677            tags=d.get('tags'),
 2678            username=d.get('username'),
 2679        )
 2680
 2681
 2682class Azure:
 2683    __slots__ = [
 2684        'app_id',
 2685        'bind_interface',
 2686        'egress_filter',
 2687        'healthy',
 2688        'id',
 2689        'name',
 2690        'password',
 2691        'secret_store_id',
 2692        'tags',
 2693        'tenant_id',
 2694    ]
 2695
 2696    def __init__(
 2697        self,
 2698        app_id=None,
 2699        bind_interface=None,
 2700        egress_filter=None,
 2701        healthy=None,
 2702        id=None,
 2703        name=None,
 2704        password=None,
 2705        secret_store_id=None,
 2706        tags=None,
 2707        tenant_id=None,
 2708    ):
 2709        self.app_id = app_id if app_id is not None else ''
 2710        self.bind_interface = bind_interface if bind_interface is not None else ''
 2711        '''
 2712         Bind interface
 2713        '''
 2714        self.egress_filter = egress_filter if egress_filter is not None else ''
 2715        '''
 2716         A filter applied to the routing logic to pin datasource to nodes.
 2717        '''
 2718        self.healthy = healthy if healthy is not None else False
 2719        '''
 2720         True if the datasource is reachable and the credentials are valid.
 2721        '''
 2722        self.id = id if id is not None else ''
 2723        '''
 2724         Unique identifier of the Resource.
 2725        '''
 2726        self.name = name if name is not None else ''
 2727        '''
 2728         Unique human-readable name of the Resource.
 2729        '''
 2730        self.password = password if password is not None else ''
 2731        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2732        '''
 2733         ID of the secret store containing credentials for this resource, if any.
 2734        '''
 2735        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2736        '''
 2737         Tags is a map of key, value pairs.
 2738        '''
 2739        self.tenant_id = tenant_id if tenant_id is not None else ''
 2740
 2741    def __repr__(self):
 2742        return '<sdm.Azure ' + \
 2743            'app_id: ' + repr(self.app_id) + ' ' +\
 2744            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2745            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2746            'healthy: ' + repr(self.healthy) + ' ' +\
 2747            'id: ' + repr(self.id) + ' ' +\
 2748            'name: ' + repr(self.name) + ' ' +\
 2749            'password: ' + repr(self.password) + ' ' +\
 2750            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2751            'tags: ' + repr(self.tags) + ' ' +\
 2752            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2753            '>'
 2754
 2755    def to_dict(self):
 2756        return {
 2757            'app_id': self.app_id,
 2758            'bind_interface': self.bind_interface,
 2759            'egress_filter': self.egress_filter,
 2760            'healthy': self.healthy,
 2761            'id': self.id,
 2762            'name': self.name,
 2763            'password': self.password,
 2764            'secret_store_id': self.secret_store_id,
 2765            'tags': self.tags,
 2766            'tenant_id': self.tenant_id,
 2767        }
 2768
 2769    @classmethod
 2770    def from_dict(cls, d):
 2771        return cls(
 2772            app_id=d.get('app_id'),
 2773            bind_interface=d.get('bind_interface'),
 2774            egress_filter=d.get('egress_filter'),
 2775            healthy=d.get('healthy'),
 2776            id=d.get('id'),
 2777            name=d.get('name'),
 2778            password=d.get('password'),
 2779            secret_store_id=d.get('secret_store_id'),
 2780            tags=d.get('tags'),
 2781            tenant_id=d.get('tenant_id'),
 2782        )
 2783
 2784
 2785class AzureCertificate:
 2786    __slots__ = [
 2787        'app_id',
 2788        'bind_interface',
 2789        'client_certificate',
 2790        'egress_filter',
 2791        'healthy',
 2792        'id',
 2793        'name',
 2794        'secret_store_id',
 2795        'tags',
 2796        'tenant_id',
 2797    ]
 2798
 2799    def __init__(
 2800        self,
 2801        app_id=None,
 2802        bind_interface=None,
 2803        client_certificate=None,
 2804        egress_filter=None,
 2805        healthy=None,
 2806        id=None,
 2807        name=None,
 2808        secret_store_id=None,
 2809        tags=None,
 2810        tenant_id=None,
 2811    ):
 2812        self.app_id = app_id if app_id is not None else ''
 2813        self.bind_interface = bind_interface if bind_interface is not None else ''
 2814        '''
 2815         Bind interface
 2816        '''
 2817        self.client_certificate = client_certificate if client_certificate is not None else ''
 2818        self.egress_filter = egress_filter if egress_filter is not None else ''
 2819        '''
 2820         A filter applied to the routing logic to pin datasource to nodes.
 2821        '''
 2822        self.healthy = healthy if healthy is not None else False
 2823        '''
 2824         True if the datasource is reachable and the credentials are valid.
 2825        '''
 2826        self.id = id if id is not None else ''
 2827        '''
 2828         Unique identifier of the Resource.
 2829        '''
 2830        self.name = name if name is not None else ''
 2831        '''
 2832         Unique human-readable name of the Resource.
 2833        '''
 2834        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2835        '''
 2836         ID of the secret store containing credentials for this resource, if any.
 2837        '''
 2838        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2839        '''
 2840         Tags is a map of key, value pairs.
 2841        '''
 2842        self.tenant_id = tenant_id if tenant_id is not None else ''
 2843
 2844    def __repr__(self):
 2845        return '<sdm.AzureCertificate ' + \
 2846            'app_id: ' + repr(self.app_id) + ' ' +\
 2847            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2848            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2849            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2850            'healthy: ' + repr(self.healthy) + ' ' +\
 2851            'id: ' + repr(self.id) + ' ' +\
 2852            'name: ' + repr(self.name) + ' ' +\
 2853            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2854            'tags: ' + repr(self.tags) + ' ' +\
 2855            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2856            '>'
 2857
 2858    def to_dict(self):
 2859        return {
 2860            'app_id': self.app_id,
 2861            'bind_interface': self.bind_interface,
 2862            'client_certificate': self.client_certificate,
 2863            'egress_filter': self.egress_filter,
 2864            'healthy': self.healthy,
 2865            'id': self.id,
 2866            'name': self.name,
 2867            'secret_store_id': self.secret_store_id,
 2868            'tags': self.tags,
 2869            'tenant_id': self.tenant_id,
 2870        }
 2871
 2872    @classmethod
 2873    def from_dict(cls, d):
 2874        return cls(
 2875            app_id=d.get('app_id'),
 2876            bind_interface=d.get('bind_interface'),
 2877            client_certificate=d.get('client_certificate'),
 2878            egress_filter=d.get('egress_filter'),
 2879            healthy=d.get('healthy'),
 2880            id=d.get('id'),
 2881            name=d.get('name'),
 2882            secret_store_id=d.get('secret_store_id'),
 2883            tags=d.get('tags'),
 2884            tenant_id=d.get('tenant_id'),
 2885        )
 2886
 2887
 2888class AzureMysql:
 2889    '''
 2890    AzureMysql is currently unstable, and its API may change, or it may be removed,
 2891    without a major version bump.
 2892    '''
 2893    __slots__ = [
 2894        'bind_interface',
 2895        'database',
 2896        'egress_filter',
 2897        'healthy',
 2898        'hostname',
 2899        'id',
 2900        'name',
 2901        'password',
 2902        'port',
 2903        'port_override',
 2904        'secret_store_id',
 2905        'tags',
 2906        'username',
 2907    ]
 2908
 2909    def __init__(
 2910        self,
 2911        bind_interface=None,
 2912        database=None,
 2913        egress_filter=None,
 2914        healthy=None,
 2915        hostname=None,
 2916        id=None,
 2917        name=None,
 2918        password=None,
 2919        port=None,
 2920        port_override=None,
 2921        secret_store_id=None,
 2922        tags=None,
 2923        username=None,
 2924    ):
 2925        self.bind_interface = bind_interface if bind_interface is not None else ''
 2926        '''
 2927         Bind interface
 2928        '''
 2929        self.database = database if database is not None else ''
 2930        self.egress_filter = egress_filter if egress_filter is not None else ''
 2931        '''
 2932         A filter applied to the routing logic to pin datasource to nodes.
 2933        '''
 2934        self.healthy = healthy if healthy is not None else False
 2935        '''
 2936         True if the datasource is reachable and the credentials are valid.
 2937        '''
 2938        self.hostname = hostname if hostname is not None else ''
 2939        self.id = id if id is not None else ''
 2940        '''
 2941         Unique identifier of the Resource.
 2942        '''
 2943        self.name = name if name is not None else ''
 2944        '''
 2945         Unique human-readable name of the Resource.
 2946        '''
 2947        self.password = password if password is not None else ''
 2948        self.port = port if port is not None else 0
 2949        self.port_override = port_override if port_override is not None else 0
 2950        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2951        '''
 2952         ID of the secret store containing credentials for this resource, if any.
 2953        '''
 2954        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2955        '''
 2956         Tags is a map of key, value pairs.
 2957        '''
 2958        self.username = username if username is not None else ''
 2959
 2960    def __repr__(self):
 2961        return '<sdm.AzureMysql ' + \
 2962            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2963            'database: ' + repr(self.database) + ' ' +\
 2964            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2965            'healthy: ' + repr(self.healthy) + ' ' +\
 2966            'hostname: ' + repr(self.hostname) + ' ' +\
 2967            'id: ' + repr(self.id) + ' ' +\
 2968            'name: ' + repr(self.name) + ' ' +\
 2969            'password: ' + repr(self.password) + ' ' +\
 2970            'port: ' + repr(self.port) + ' ' +\
 2971            'port_override: ' + repr(self.port_override) + ' ' +\
 2972            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2973            'tags: ' + repr(self.tags) + ' ' +\
 2974            'username: ' + repr(self.username) + ' ' +\
 2975            '>'
 2976
 2977    def to_dict(self):
 2978        return {
 2979            'bind_interface': self.bind_interface,
 2980            'database': self.database,
 2981            'egress_filter': self.egress_filter,
 2982            'healthy': self.healthy,
 2983            'hostname': self.hostname,
 2984            'id': self.id,
 2985            'name': self.name,
 2986            'password': self.password,
 2987            'port': self.port,
 2988            'port_override': self.port_override,
 2989            'secret_store_id': self.secret_store_id,
 2990            'tags': self.tags,
 2991            'username': self.username,
 2992        }
 2993
 2994    @classmethod
 2995    def from_dict(cls, d):
 2996        return cls(
 2997            bind_interface=d.get('bind_interface'),
 2998            database=d.get('database'),
 2999            egress_filter=d.get('egress_filter'),
 3000            healthy=d.get('healthy'),
 3001            hostname=d.get('hostname'),
 3002            id=d.get('id'),
 3003            name=d.get('name'),
 3004            password=d.get('password'),
 3005            port=d.get('port'),
 3006            port_override=d.get('port_override'),
 3007            secret_store_id=d.get('secret_store_id'),
 3008            tags=d.get('tags'),
 3009            username=d.get('username'),
 3010        )
 3011
 3012
 3013class AzurePostgres:
 3014    __slots__ = [
 3015        'bind_interface',
 3016        'database',
 3017        'egress_filter',
 3018        'healthy',
 3019        'hostname',
 3020        'id',
 3021        'name',
 3022        'override_database',
 3023        'password',
 3024        'port',
 3025        'port_override',
 3026        'secret_store_id',
 3027        'tags',
 3028        'username',
 3029    ]
 3030
 3031    def __init__(
 3032        self,
 3033        bind_interface=None,
 3034        database=None,
 3035        egress_filter=None,
 3036        healthy=None,
 3037        hostname=None,
 3038        id=None,
 3039        name=None,
 3040        override_database=None,
 3041        password=None,
 3042        port=None,
 3043        port_override=None,
 3044        secret_store_id=None,
 3045        tags=None,
 3046        username=None,
 3047    ):
 3048        self.bind_interface = bind_interface if bind_interface is not None else ''
 3049        '''
 3050         Bind interface
 3051        '''
 3052        self.database = database if database is not None else ''
 3053        self.egress_filter = egress_filter if egress_filter is not None else ''
 3054        '''
 3055         A filter applied to the routing logic to pin datasource to nodes.
 3056        '''
 3057        self.healthy = healthy if healthy is not None else False
 3058        '''
 3059         True if the datasource is reachable and the credentials are valid.
 3060        '''
 3061        self.hostname = hostname if hostname is not None else ''
 3062        self.id = id if id is not None else ''
 3063        '''
 3064         Unique identifier of the Resource.
 3065        '''
 3066        self.name = name if name is not None else ''
 3067        '''
 3068         Unique human-readable name of the Resource.
 3069        '''
 3070        self.override_database = override_database if override_database is not None else False
 3071        self.password = password if password is not None else ''
 3072        self.port = port if port is not None else 0
 3073        self.port_override = port_override if port_override is not None else 0
 3074        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3075        '''
 3076         ID of the secret store containing credentials for this resource, if any.
 3077        '''
 3078        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3079        '''
 3080         Tags is a map of key, value pairs.
 3081        '''
 3082        self.username = username if username is not None else ''
 3083
 3084    def __repr__(self):
 3085        return '<sdm.AzurePostgres ' + \
 3086            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3087            'database: ' + repr(self.database) + ' ' +\
 3088            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3089            'healthy: ' + repr(self.healthy) + ' ' +\
 3090            'hostname: ' + repr(self.hostname) + ' ' +\
 3091            'id: ' + repr(self.id) + ' ' +\
 3092            'name: ' + repr(self.name) + ' ' +\
 3093            'override_database: ' + repr(self.override_database) + ' ' +\
 3094            'password: ' + repr(self.password) + ' ' +\
 3095            'port: ' + repr(self.port) + ' ' +\
 3096            'port_override: ' + repr(self.port_override) + ' ' +\
 3097            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3098            'tags: ' + repr(self.tags) + ' ' +\
 3099            'username: ' + repr(self.username) + ' ' +\
 3100            '>'
 3101
 3102    def to_dict(self):
 3103        return {
 3104            'bind_interface': self.bind_interface,
 3105            'database': self.database,
 3106            'egress_filter': self.egress_filter,
 3107            'healthy': self.healthy,
 3108            'hostname': self.hostname,
 3109            'id': self.id,
 3110            'name': self.name,
 3111            'override_database': self.override_database,
 3112            'password': self.password,
 3113            'port': self.port,
 3114            'port_override': self.port_override,
 3115            'secret_store_id': self.secret_store_id,
 3116            'tags': self.tags,
 3117            'username': self.username,
 3118        }
 3119
 3120    @classmethod
 3121    def from_dict(cls, d):
 3122        return cls(
 3123            bind_interface=d.get('bind_interface'),
 3124            database=d.get('database'),
 3125            egress_filter=d.get('egress_filter'),
 3126            healthy=d.get('healthy'),
 3127            hostname=d.get('hostname'),
 3128            id=d.get('id'),
 3129            name=d.get('name'),
 3130            override_database=d.get('override_database'),
 3131            password=d.get('password'),
 3132            port=d.get('port'),
 3133            port_override=d.get('port_override'),
 3134            secret_store_id=d.get('secret_store_id'),
 3135            tags=d.get('tags'),
 3136            username=d.get('username'),
 3137        )
 3138
 3139
 3140class AzureStore:
 3141    __slots__ = [
 3142        'id',
 3143        'name',
 3144        'tags',
 3145        'vault_uri',
 3146    ]
 3147
 3148    def __init__(
 3149        self,
 3150        id=None,
 3151        name=None,
 3152        tags=None,
 3153        vault_uri=None,
 3154    ):
 3155        self.id = id if id is not None else ''
 3156        '''
 3157         Unique identifier of the SecretStore.
 3158        '''
 3159        self.name = name if name is not None else ''
 3160        '''
 3161         Unique human-readable name of the SecretStore.
 3162        '''
 3163        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3164        '''
 3165         Tags is a map of key, value pairs.
 3166        '''
 3167        self.vault_uri = vault_uri if vault_uri is not None else ''
 3168
 3169    def __repr__(self):
 3170        return '<sdm.AzureStore ' + \
 3171            'id: ' + repr(self.id) + ' ' +\
 3172            'name: ' + repr(self.name) + ' ' +\
 3173            'tags: ' + repr(self.tags) + ' ' +\
 3174            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 3175            '>'
 3176
 3177    def to_dict(self):
 3178        return {
 3179            'id': self.id,
 3180            'name': self.name,
 3181            'tags': self.tags,
 3182            'vault_uri': self.vault_uri,
 3183        }
 3184
 3185    @classmethod
 3186    def from_dict(cls, d):
 3187        return cls(
 3188            id=d.get('id'),
 3189            name=d.get('name'),
 3190            tags=d.get('tags'),
 3191            vault_uri=d.get('vault_uri'),
 3192        )
 3193
 3194
 3195class BigQuery:
 3196    __slots__ = [
 3197        'bind_interface',
 3198        'egress_filter',
 3199        'endpoint',
 3200        'healthy',
 3201        'id',
 3202        'name',
 3203        'port_override',
 3204        'private_key',
 3205        'project',
 3206        'secret_store_id',
 3207        'tags',
 3208        'username',
 3209    ]
 3210
 3211    def __init__(
 3212        self,
 3213        bind_interface=None,
 3214        egress_filter=None,
 3215        endpoint=None,
 3216        healthy=None,
 3217        id=None,
 3218        name=None,
 3219        port_override=None,
 3220        private_key=None,
 3221        project=None,
 3222        secret_store_id=None,
 3223        tags=None,
 3224        username=None,
 3225    ):
 3226        self.bind_interface = bind_interface if bind_interface is not None else ''
 3227        '''
 3228         Bind interface
 3229        '''
 3230        self.egress_filter = egress_filter if egress_filter is not None else ''
 3231        '''
 3232         A filter applied to the routing logic to pin datasource to nodes.
 3233        '''
 3234        self.endpoint = endpoint if endpoint is not None else ''
 3235        self.healthy = healthy if healthy is not None else False
 3236        '''
 3237         True if the datasource is reachable and the credentials are valid.
 3238        '''
 3239        self.id = id if id is not None else ''
 3240        '''
 3241         Unique identifier of the Resource.
 3242        '''
 3243        self.name = name if name is not None else ''
 3244        '''
 3245         Unique human-readable name of the Resource.
 3246        '''
 3247        self.port_override = port_override if port_override is not None else 0
 3248        self.private_key = private_key if private_key is not None else ''
 3249        self.project = project if project is not None else ''
 3250        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3251        '''
 3252         ID of the secret store containing credentials for this resource, if any.
 3253        '''
 3254        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3255        '''
 3256         Tags is a map of key, value pairs.
 3257        '''
 3258        self.username = username if username is not None else ''
 3259
 3260    def __repr__(self):
 3261        return '<sdm.BigQuery ' + \
 3262            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3263            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3264            'endpoint: ' + repr(self.endpoint) + ' ' +\
 3265            'healthy: ' + repr(self.healthy) + ' ' +\
 3266            'id: ' + repr(self.id) + ' ' +\
 3267            'name: ' + repr(self.name) + ' ' +\
 3268            'port_override: ' + repr(self.port_override) + ' ' +\
 3269            'private_key: ' + repr(self.private_key) + ' ' +\
 3270            'project: ' + repr(self.project) + ' ' +\
 3271            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3272            'tags: ' + repr(self.tags) + ' ' +\
 3273            'username: ' + repr(self.username) + ' ' +\
 3274            '>'
 3275
 3276    def to_dict(self):
 3277        return {
 3278            'bind_interface': self.bind_interface,
 3279            'egress_filter': self.egress_filter,
 3280            'endpoint': self.endpoint,
 3281            'healthy': self.healthy,
 3282            'id': self.id,
 3283            'name': self.name,
 3284            'port_override': self.port_override,
 3285            'private_key': self.private_key,
 3286            'project': self.project,
 3287            'secret_store_id': self.secret_store_id,
 3288            'tags': self.tags,
 3289            'username': self.username,
 3290        }
 3291
 3292    @classmethod
 3293    def from_dict(cls, d):
 3294        return cls(
 3295            bind_interface=d.get('bind_interface'),
 3296            egress_filter=d.get('egress_filter'),
 3297            endpoint=d.get('endpoint'),
 3298            healthy=d.get('healthy'),
 3299            id=d.get('id'),
 3300            name=d.get('name'),
 3301            port_override=d.get('port_override'),
 3302            private_key=d.get('private_key'),
 3303            project=d.get('project'),
 3304            secret_store_id=d.get('secret_store_id'),
 3305            tags=d.get('tags'),
 3306            username=d.get('username'),
 3307        )
 3308
 3309
 3310class Cassandra:
 3311    __slots__ = [
 3312        'bind_interface',
 3313        'egress_filter',
 3314        'healthy',
 3315        'hostname',
 3316        'id',
 3317        'name',
 3318        'password',
 3319        'port',
 3320        'port_override',
 3321        'secret_store_id',
 3322        'tags',
 3323        'tls_required',
 3324        'username',
 3325    ]
 3326
 3327    def __init__(
 3328        self,
 3329        bind_interface=None,
 3330        egress_filter=None,
 3331        healthy=None,
 3332        hostname=None,
 3333        id=None,
 3334        name=None,
 3335        password=None,
 3336        port=None,
 3337        port_override=None,
 3338        secret_store_id=None,
 3339        tags=None,
 3340        tls_required=None,
 3341        username=None,
 3342    ):
 3343        self.bind_interface = bind_interface if bind_interface is not None else ''
 3344        '''
 3345         Bind interface
 3346        '''
 3347        self.egress_filter = egress_filter if egress_filter is not None else ''
 3348        '''
 3349         A filter applied to the routing logic to pin datasource to nodes.
 3350        '''
 3351        self.healthy = healthy if healthy is not None else False
 3352        '''
 3353         True if the datasource is reachable and the credentials are valid.
 3354        '''
 3355        self.hostname = hostname if hostname is not None else ''
 3356        self.id = id if id is not None else ''
 3357        '''
 3358         Unique identifier of the Resource.
 3359        '''
 3360        self.name = name if name is not None else ''
 3361        '''
 3362         Unique human-readable name of the Resource.
 3363        '''
 3364        self.password = password if password is not None else ''
 3365        self.port = port if port is not None else 0
 3366        self.port_override = port_override if port_override is not None else 0
 3367        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3368        '''
 3369         ID of the secret store containing credentials for this resource, if any.
 3370        '''
 3371        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3372        '''
 3373         Tags is a map of key, value pairs.
 3374        '''
 3375        self.tls_required = tls_required if tls_required is not None else False
 3376        self.username = username if username is not None else ''
 3377
 3378    def __repr__(self):
 3379        return '<sdm.Cassandra ' + \
 3380            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3381            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3382            'healthy: ' + repr(self.healthy) + ' ' +\
 3383            'hostname: ' + repr(self.hostname) + ' ' +\
 3384            'id: ' + repr(self.id) + ' ' +\
 3385            'name: ' + repr(self.name) + ' ' +\
 3386            'password: ' + repr(self.password) + ' ' +\
 3387            'port: ' + repr(self.port) + ' ' +\
 3388            'port_override: ' + repr(self.port_override) + ' ' +\
 3389            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3390            'tags: ' + repr(self.tags) + ' ' +\
 3391            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3392            'username: ' + repr(self.username) + ' ' +\
 3393            '>'
 3394
 3395    def to_dict(self):
 3396        return {
 3397            'bind_interface': self.bind_interface,
 3398            'egress_filter': self.egress_filter,
 3399            'healthy': self.healthy,
 3400            'hostname': self.hostname,
 3401            'id': self.id,
 3402            'name': self.name,
 3403            'password': self.password,
 3404            'port': self.port,
 3405            'port_override': self.port_override,
 3406            'secret_store_id': self.secret_store_id,
 3407            'tags': self.tags,
 3408            'tls_required': self.tls_required,
 3409            'username': self.username,
 3410        }
 3411
 3412    @classmethod
 3413    def from_dict(cls, d):
 3414        return cls(
 3415            bind_interface=d.get('bind_interface'),
 3416            egress_filter=d.get('egress_filter'),
 3417            healthy=d.get('healthy'),
 3418            hostname=d.get('hostname'),
 3419            id=d.get('id'),
 3420            name=d.get('name'),
 3421            password=d.get('password'),
 3422            port=d.get('port'),
 3423            port_override=d.get('port_override'),
 3424            secret_store_id=d.get('secret_store_id'),
 3425            tags=d.get('tags'),
 3426            tls_required=d.get('tls_required'),
 3427            username=d.get('username'),
 3428        )
 3429
 3430
 3431class Citus:
 3432    __slots__ = [
 3433        'bind_interface',
 3434        'database',
 3435        'egress_filter',
 3436        'healthy',
 3437        'hostname',
 3438        'id',
 3439        'name',
 3440        'override_database',
 3441        'password',
 3442        'port',
 3443        'port_override',
 3444        'secret_store_id',
 3445        'tags',
 3446        'username',
 3447    ]
 3448
 3449    def __init__(
 3450        self,
 3451        bind_interface=None,
 3452        database=None,
 3453        egress_filter=None,
 3454        healthy=None,
 3455        hostname=None,
 3456        id=None,
 3457        name=None,
 3458        override_database=None,
 3459        password=None,
 3460        port=None,
 3461        port_override=None,
 3462        secret_store_id=None,
 3463        tags=None,
 3464        username=None,
 3465    ):
 3466        self.bind_interface = bind_interface if bind_interface is not None else ''
 3467        '''
 3468         Bind interface
 3469        '''
 3470        self.database = database if database is not None else ''
 3471        self.egress_filter = egress_filter if egress_filter is not None else ''
 3472        '''
 3473         A filter applied to the routing logic to pin datasource to nodes.
 3474        '''
 3475        self.healthy = healthy if healthy is not None else False
 3476        '''
 3477         True if the datasource is reachable and the credentials are valid.
 3478        '''
 3479        self.hostname = hostname if hostname is not None else ''
 3480        self.id = id if id is not None else ''
 3481        '''
 3482         Unique identifier of the Resource.
 3483        '''
 3484        self.name = name if name is not None else ''
 3485        '''
 3486         Unique human-readable name of the Resource.
 3487        '''
 3488        self.override_database = override_database if override_database is not None else False
 3489        self.password = password if password is not None else ''
 3490        self.port = port if port is not None else 0
 3491        self.port_override = port_override if port_override is not None else 0
 3492        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3493        '''
 3494         ID of the secret store containing credentials for this resource, if any.
 3495        '''
 3496        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3497        '''
 3498         Tags is a map of key, value pairs.
 3499        '''
 3500        self.username = username if username is not None else ''
 3501
 3502    def __repr__(self):
 3503        return '<sdm.Citus ' + \
 3504            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3505            'database: ' + repr(self.database) + ' ' +\
 3506            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3507            'healthy: ' + repr(self.healthy) + ' ' +\
 3508            'hostname: ' + repr(self.hostname) + ' ' +\
 3509            'id: ' + repr(self.id) + ' ' +\
 3510            'name: ' + repr(self.name) + ' ' +\
 3511            'override_database: ' + repr(self.override_database) + ' ' +\
 3512            'password: ' + repr(self.password) + ' ' +\
 3513            'port: ' + repr(self.port) + ' ' +\
 3514            'port_override: ' + repr(self.port_override) + ' ' +\
 3515            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3516            'tags: ' + repr(self.tags) + ' ' +\
 3517            'username: ' + repr(self.username) + ' ' +\
 3518            '>'
 3519
 3520    def to_dict(self):
 3521        return {
 3522            'bind_interface': self.bind_interface,
 3523            'database': self.database,
 3524            'egress_filter': self.egress_filter,
 3525            'healthy': self.healthy,
 3526            'hostname': self.hostname,
 3527            'id': self.id,
 3528            'name': self.name,
 3529            'override_database': self.override_database,
 3530            'password': self.password,
 3531            'port': self.port,
 3532            'port_override': self.port_override,
 3533            'secret_store_id': self.secret_store_id,
 3534            'tags': self.tags,
 3535            'username': self.username,
 3536        }
 3537
 3538    @classmethod
 3539    def from_dict(cls, d):
 3540        return cls(
 3541            bind_interface=d.get('bind_interface'),
 3542            database=d.get('database'),
 3543            egress_filter=d.get('egress_filter'),
 3544            healthy=d.get('healthy'),
 3545            hostname=d.get('hostname'),
 3546            id=d.get('id'),
 3547            name=d.get('name'),
 3548            override_database=d.get('override_database'),
 3549            password=d.get('password'),
 3550            port=d.get('port'),
 3551            port_override=d.get('port_override'),
 3552            secret_store_id=d.get('secret_store_id'),
 3553            tags=d.get('tags'),
 3554            username=d.get('username'),
 3555        )
 3556
 3557
 3558class Clustrix:
 3559    __slots__ = [
 3560        'bind_interface',
 3561        'database',
 3562        'egress_filter',
 3563        'healthy',
 3564        'hostname',
 3565        'id',
 3566        'name',
 3567        'password',
 3568        'port',
 3569        'port_override',
 3570        'secret_store_id',
 3571        'tags',
 3572        'username',
 3573    ]
 3574
 3575    def __init__(
 3576        self,
 3577        bind_interface=None,
 3578        database=None,
 3579        egress_filter=None,
 3580        healthy=None,
 3581        hostname=None,
 3582        id=None,
 3583        name=None,
 3584        password=None,
 3585        port=None,
 3586        port_override=None,
 3587        secret_store_id=None,
 3588        tags=None,
 3589        username=None,
 3590    ):
 3591        self.bind_interface = bind_interface if bind_interface is not None else ''
 3592        '''
 3593         Bind interface
 3594        '''
 3595        self.database = database if database is not None else ''
 3596        self.egress_filter = egress_filter if egress_filter is not None else ''
 3597        '''
 3598         A filter applied to the routing logic to pin datasource to nodes.
 3599        '''
 3600        self.healthy = healthy if healthy is not None else False
 3601        '''
 3602         True if the datasource is reachable and the credentials are valid.
 3603        '''
 3604        self.hostname = hostname if hostname is not None else ''
 3605        self.id = id if id is not None else ''
 3606        '''
 3607         Unique identifier of the Resource.
 3608        '''
 3609        self.name = name if name is not None else ''
 3610        '''
 3611         Unique human-readable name of the Resource.
 3612        '''
 3613        self.password = password if password is not None else ''
 3614        self.port = port if port is not None else 0
 3615        self.port_override = port_override if port_override is not None else 0
 3616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3617        '''
 3618         ID of the secret store containing credentials for this resource, if any.
 3619        '''
 3620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3621        '''
 3622         Tags is a map of key, value pairs.
 3623        '''
 3624        self.username = username if username is not None else ''
 3625
 3626    def __repr__(self):
 3627        return '<sdm.Clustrix ' + \
 3628            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3629            'database: ' + repr(self.database) + ' ' +\
 3630            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3631            'healthy: ' + repr(self.healthy) + ' ' +\
 3632            'hostname: ' + repr(self.hostname) + ' ' +\
 3633            'id: ' + repr(self.id) + ' ' +\
 3634            'name: ' + repr(self.name) + ' ' +\
 3635            'password: ' + repr(self.password) + ' ' +\
 3636            'port: ' + repr(self.port) + ' ' +\
 3637            'port_override: ' + repr(self.port_override) + ' ' +\
 3638            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3639            'tags: ' + repr(self.tags) + ' ' +\
 3640            'username: ' + repr(self.username) + ' ' +\
 3641            '>'
 3642
 3643    def to_dict(self):
 3644        return {
 3645            'bind_interface': self.bind_interface,
 3646            'database': self.database,
 3647            'egress_filter': self.egress_filter,
 3648            'healthy': self.healthy,
 3649            'hostname': self.hostname,
 3650            'id': self.id,
 3651            'name': self.name,
 3652            'password': self.password,
 3653            'port': self.port,
 3654            'port_override': self.port_override,
 3655            'secret_store_id': self.secret_store_id,
 3656            'tags': self.tags,
 3657            'username': self.username,
 3658        }
 3659
 3660    @classmethod
 3661    def from_dict(cls, d):
 3662        return cls(
 3663            bind_interface=d.get('bind_interface'),
 3664            database=d.get('database'),
 3665            egress_filter=d.get('egress_filter'),
 3666            healthy=d.get('healthy'),
 3667            hostname=d.get('hostname'),
 3668            id=d.get('id'),
 3669            name=d.get('name'),
 3670            password=d.get('password'),
 3671            port=d.get('port'),
 3672            port_override=d.get('port_override'),
 3673            secret_store_id=d.get('secret_store_id'),
 3674            tags=d.get('tags'),
 3675            username=d.get('username'),
 3676        )
 3677
 3678
 3679class Cockroach:
 3680    __slots__ = [
 3681        'bind_interface',
 3682        'database',
 3683        'egress_filter',
 3684        'healthy',
 3685        'hostname',
 3686        'id',
 3687        'name',
 3688        'override_database',
 3689        'password',
 3690        'port',
 3691        'port_override',
 3692        'secret_store_id',
 3693        'tags',
 3694        'username',
 3695    ]
 3696
 3697    def __init__(
 3698        self,
 3699        bind_interface=None,
 3700        database=None,
 3701        egress_filter=None,
 3702        healthy=None,
 3703        hostname=None,
 3704        id=None,
 3705        name=None,
 3706        override_database=None,
 3707        password=None,
 3708        port=None,
 3709        port_override=None,
 3710        secret_store_id=None,
 3711        tags=None,
 3712        username=None,
 3713    ):
 3714        self.bind_interface = bind_interface if bind_interface is not None else ''
 3715        '''
 3716         Bind interface
 3717        '''
 3718        self.database = database if database is not None else ''
 3719        self.egress_filter = egress_filter if egress_filter is not None else ''
 3720        '''
 3721         A filter applied to the routing logic to pin datasource to nodes.
 3722        '''
 3723        self.healthy = healthy if healthy is not None else False
 3724        '''
 3725         True if the datasource is reachable and the credentials are valid.
 3726        '''
 3727        self.hostname = hostname if hostname is not None else ''
 3728        self.id = id if id is not None else ''
 3729        '''
 3730         Unique identifier of the Resource.
 3731        '''
 3732        self.name = name if name is not None else ''
 3733        '''
 3734         Unique human-readable name of the Resource.
 3735        '''
 3736        self.override_database = override_database if override_database is not None else False
 3737        self.password = password if password is not None else ''
 3738        self.port = port if port is not None else 0
 3739        self.port_override = port_override if port_override is not None else 0
 3740        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3741        '''
 3742         ID of the secret store containing credentials for this resource, if any.
 3743        '''
 3744        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3745        '''
 3746         Tags is a map of key, value pairs.
 3747        '''
 3748        self.username = username if username is not None else ''
 3749
 3750    def __repr__(self):
 3751        return '<sdm.Cockroach ' + \
 3752            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3753            'database: ' + repr(self.database) + ' ' +\
 3754            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3755            'healthy: ' + repr(self.healthy) + ' ' +\
 3756            'hostname: ' + repr(self.hostname) + ' ' +\
 3757            'id: ' + repr(self.id) + ' ' +\
 3758            'name: ' + repr(self.name) + ' ' +\
 3759            'override_database: ' + repr(self.override_database) + ' ' +\
 3760            'password: ' + repr(self.password) + ' ' +\
 3761            'port: ' + repr(self.port) + ' ' +\
 3762            'port_override: ' + repr(self.port_override) + ' ' +\
 3763            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3764            'tags: ' + repr(self.tags) + ' ' +\
 3765            'username: ' + repr(self.username) + ' ' +\
 3766            '>'
 3767
 3768    def to_dict(self):
 3769        return {
 3770            'bind_interface': self.bind_interface,
 3771            'database': self.database,
 3772            'egress_filter': self.egress_filter,
 3773            'healthy': self.healthy,
 3774            'hostname': self.hostname,
 3775            'id': self.id,
 3776            'name': self.name,
 3777            'override_database': self.override_database,
 3778            'password': self.password,
 3779            'port': self.port,
 3780            'port_override': self.port_override,
 3781            'secret_store_id': self.secret_store_id,
 3782            'tags': self.tags,
 3783            'username': self.username,
 3784        }
 3785
 3786    @classmethod
 3787    def from_dict(cls, d):
 3788        return cls(
 3789            bind_interface=d.get('bind_interface'),
 3790            database=d.get('database'),
 3791            egress_filter=d.get('egress_filter'),
 3792            healthy=d.get('healthy'),
 3793            hostname=d.get('hostname'),
 3794            id=d.get('id'),
 3795            name=d.get('name'),
 3796            override_database=d.get('override_database'),
 3797            password=d.get('password'),
 3798            port=d.get('port'),
 3799            port_override=d.get('port_override'),
 3800            secret_store_id=d.get('secret_store_id'),
 3801            tags=d.get('tags'),
 3802            username=d.get('username'),
 3803        )
 3804
 3805
 3806class ControlPanelGetSSHCAPublicKeyResponse:
 3807    '''
 3808         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3809     organization's SSH Certificate Authority public key.
 3810    '''
 3811    __slots__ = [
 3812        'meta',
 3813        'public_key',
 3814        'rate_limit',
 3815    ]
 3816
 3817    def __init__(
 3818        self,
 3819        meta=None,
 3820        public_key=None,
 3821        rate_limit=None,
 3822    ):
 3823        self.meta = meta if meta is not None else None
 3824        '''
 3825         Reserved for future use.
 3826        '''
 3827        self.public_key = public_key if public_key is not None else ''
 3828        '''
 3829         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3830         key format.
 3831        '''
 3832        self.rate_limit = rate_limit if rate_limit is not None else None
 3833        '''
 3834         Rate limit information.
 3835        '''
 3836
 3837    def __repr__(self):
 3838        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3839            'meta: ' + repr(self.meta) + ' ' +\
 3840            'public_key: ' + repr(self.public_key) + ' ' +\
 3841            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3842            '>'
 3843
 3844    def to_dict(self):
 3845        return {
 3846            'meta': self.meta,
 3847            'public_key': self.public_key,
 3848            'rate_limit': self.rate_limit,
 3849        }
 3850
 3851    @classmethod
 3852    def from_dict(cls, d):
 3853        return cls(
 3854            meta=d.get('meta'),
 3855            public_key=d.get('public_key'),
 3856            rate_limit=d.get('rate_limit'),
 3857        )
 3858
 3859
 3860class ControlPanelVerifyJWTResponse:
 3861    '''
 3862         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3863    '''
 3864    __slots__ = [
 3865        'meta',
 3866        'rate_limit',
 3867        'valid',
 3868    ]
 3869
 3870    def __init__(
 3871        self,
 3872        meta=None,
 3873        rate_limit=None,
 3874        valid=None,
 3875    ):
 3876        self.meta = meta if meta is not None else None
 3877        '''
 3878         Reserved for future use.
 3879        '''
 3880        self.rate_limit = rate_limit if rate_limit is not None else None
 3881        '''
 3882         Rate limit information.
 3883        '''
 3884        self.valid = valid if valid is not None else False
 3885        '''
 3886         Reports if the given token is valid.
 3887        '''
 3888
 3889    def __repr__(self):
 3890        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3891            'meta: ' + repr(self.meta) + ' ' +\
 3892            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3893            'valid: ' + repr(self.valid) + ' ' +\
 3894            '>'
 3895
 3896    def to_dict(self):
 3897        return {
 3898            'meta': self.meta,
 3899            'rate_limit': self.rate_limit,
 3900            'valid': self.valid,
 3901        }
 3902
 3903    @classmethod
 3904    def from_dict(cls, d):
 3905        return cls(
 3906            meta=d.get('meta'),
 3907            rate_limit=d.get('rate_limit'),
 3908            valid=d.get('valid'),
 3909        )
 3910
 3911
 3912class CreateResponseMetadata:
 3913    '''
 3914         CreateResponseMetadata is reserved for future use.
 3915    '''
 3916    __slots__ = []
 3917
 3918    def __init__(self, ):
 3919        pass
 3920
 3921    def __repr__(self):
 3922        return '<sdm.CreateResponseMetadata ' + \
 3923            '>'
 3924
 3925    def to_dict(self):
 3926        return {}
 3927
 3928    @classmethod
 3929    def from_dict(cls, d):
 3930        return cls()
 3931
 3932
 3933class CyberarkConjurStore:
 3934    '''
 3935    CyberarkConjurStore is currently unstable, and its API may change, or it may be removed,
 3936    without a major version bump.
 3937    '''
 3938    __slots__ = [
 3939        'appurl',
 3940        'id',
 3941        'name',
 3942        'tags',
 3943    ]
 3944
 3945    def __init__(
 3946        self,
 3947        appurl=None,
 3948        id=None,
 3949        name=None,
 3950        tags=None,
 3951    ):
 3952        self.appurl = appurl if appurl is not None else ''
 3953        self.id = id if id is not None else ''
 3954        '''
 3955         Unique identifier of the SecretStore.
 3956        '''
 3957        self.name = name if name is not None else ''
 3958        '''
 3959         Unique human-readable name of the SecretStore.
 3960        '''
 3961        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3962        '''
 3963         Tags is a map of key, value pairs.
 3964        '''
 3965
 3966    def __repr__(self):
 3967        return '<sdm.CyberarkConjurStore ' + \
 3968            'appurl: ' + repr(self.appurl) + ' ' +\
 3969            'id: ' + repr(self.id) + ' ' +\
 3970            'name: ' + repr(self.name) + ' ' +\
 3971            'tags: ' + repr(self.tags) + ' ' +\
 3972            '>'
 3973
 3974    def to_dict(self):
 3975        return {
 3976            'appurl': self.appurl,
 3977            'id': self.id,
 3978            'name': self.name,
 3979            'tags': self.tags,
 3980        }
 3981
 3982    @classmethod
 3983    def from_dict(cls, d):
 3984        return cls(
 3985            appurl=d.get('appurl'),
 3986            id=d.get('id'),
 3987            name=d.get('name'),
 3988            tags=d.get('tags'),
 3989        )
 3990
 3991
 3992class CyberarkPAMExperimentalStore:
 3993    '''
 3994    CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed,
 3995    without a major version bump.
 3996    '''
 3997    __slots__ = [
 3998        'appurl',
 3999        'id',
 4000        'name',
 4001        'tags',
 4002    ]
 4003
 4004    def __init__(
 4005        self,
 4006        appurl=None,
 4007        id=None,
 4008        name=None,
 4009        tags=None,
 4010    ):
 4011        self.appurl = appurl if appurl is not None else ''
 4012        self.id = id if id is not None else ''
 4013        '''
 4014         Unique identifier of the SecretStore.
 4015        '''
 4016        self.name = name if name is not None else ''
 4017        '''
 4018         Unique human-readable name of the SecretStore.
 4019        '''
 4020        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4021        '''
 4022         Tags is a map of key, value pairs.
 4023        '''
 4024
 4025    def __repr__(self):
 4026        return '<sdm.CyberarkPAMExperimentalStore ' + \
 4027            'appurl: ' + repr(self.appurl) + ' ' +\
 4028            'id: ' + repr(self.id) + ' ' +\
 4029            'name: ' + repr(self.name) + ' ' +\
 4030            'tags: ' + repr(self.tags) + ' ' +\
 4031            '>'
 4032
 4033    def to_dict(self):
 4034        return {
 4035            'appurl': self.appurl,
 4036            'id': self.id,
 4037            'name': self.name,
 4038            'tags': self.tags,
 4039        }
 4040
 4041    @classmethod
 4042    def from_dict(cls, d):
 4043        return cls(
 4044            appurl=d.get('appurl'),
 4045            id=d.get('id'),
 4046            name=d.get('name'),
 4047            tags=d.get('tags'),
 4048        )
 4049
 4050
 4051class DB2I:
 4052    __slots__ = [
 4053        'bind_interface',
 4054        'egress_filter',
 4055        'healthy',
 4056        'hostname',
 4057        'id',
 4058        'name',
 4059        'password',
 4060        'port',
 4061        'port_override',
 4062        'secret_store_id',
 4063        'tags',
 4064        'tls_required',
 4065        'username',
 4066    ]
 4067
 4068    def __init__(
 4069        self,
 4070        bind_interface=None,
 4071        egress_filter=None,
 4072        healthy=None,
 4073        hostname=None,
 4074        id=None,
 4075        name=None,
 4076        password=None,
 4077        port=None,
 4078        port_override=None,
 4079        secret_store_id=None,
 4080        tags=None,
 4081        tls_required=None,
 4082        username=None,
 4083    ):
 4084        self.bind_interface = bind_interface if bind_interface is not None else ''
 4085        '''
 4086         Bind interface
 4087        '''
 4088        self.egress_filter = egress_filter if egress_filter is not None else ''
 4089        '''
 4090         A filter applied to the routing logic to pin datasource to nodes.
 4091        '''
 4092        self.healthy = healthy if healthy is not None else False
 4093        '''
 4094         True if the datasource is reachable and the credentials are valid.
 4095        '''
 4096        self.hostname = hostname if hostname is not None else ''
 4097        self.id = id if id is not None else ''
 4098        '''
 4099         Unique identifier of the Resource.
 4100        '''
 4101        self.name = name if name is not None else ''
 4102        '''
 4103         Unique human-readable name of the Resource.
 4104        '''
 4105        self.password = password if password is not None else ''
 4106        self.port = port if port is not None else 0
 4107        self.port_override = port_override if port_override is not None else 0
 4108        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4109        '''
 4110         ID of the secret store containing credentials for this resource, if any.
 4111        '''
 4112        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4113        '''
 4114         Tags is a map of key, value pairs.
 4115        '''
 4116        self.tls_required = tls_required if tls_required is not None else False
 4117        self.username = username if username is not None else ''
 4118
 4119    def __repr__(self):
 4120        return '<sdm.DB2I ' + \
 4121            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4122            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4123            'healthy: ' + repr(self.healthy) + ' ' +\
 4124            'hostname: ' + repr(self.hostname) + ' ' +\
 4125            'id: ' + repr(self.id) + ' ' +\
 4126            'name: ' + repr(self.name) + ' ' +\
 4127            'password: ' + repr(self.password) + ' ' +\
 4128            'port: ' + repr(self.port) + ' ' +\
 4129            'port_override: ' + repr(self.port_override) + ' ' +\
 4130            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4131            'tags: ' + repr(self.tags) + ' ' +\
 4132            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4133            'username: ' + repr(self.username) + ' ' +\
 4134            '>'
 4135
 4136    def to_dict(self):
 4137        return {
 4138            'bind_interface': self.bind_interface,
 4139            'egress_filter': self.egress_filter,
 4140            'healthy': self.healthy,
 4141            'hostname': self.hostname,
 4142            'id': self.id,
 4143            'name': self.name,
 4144            'password': self.password,
 4145            'port': self.port,
 4146            'port_override': self.port_override,
 4147            'secret_store_id': self.secret_store_id,
 4148            'tags': self.tags,
 4149            'tls_required': self.tls_required,
 4150            'username': self.username,
 4151        }
 4152
 4153    @classmethod
 4154    def from_dict(cls, d):
 4155        return cls(
 4156            bind_interface=d.get('bind_interface'),
 4157            egress_filter=d.get('egress_filter'),
 4158            healthy=d.get('healthy'),
 4159            hostname=d.get('hostname'),
 4160            id=d.get('id'),
 4161            name=d.get('name'),
 4162            password=d.get('password'),
 4163            port=d.get('port'),
 4164            port_override=d.get('port_override'),
 4165            secret_store_id=d.get('secret_store_id'),
 4166            tags=d.get('tags'),
 4167            tls_required=d.get('tls_required'),
 4168            username=d.get('username'),
 4169        )
 4170
 4171
 4172class DB2LUW:
 4173    __slots__ = [
 4174        'bind_interface',
 4175        'database',
 4176        'egress_filter',
 4177        'healthy',
 4178        'hostname',
 4179        'id',
 4180        'name',
 4181        'password',
 4182        'port',
 4183        'port_override',
 4184        'secret_store_id',
 4185        'tags',
 4186        'username',
 4187    ]
 4188
 4189    def __init__(
 4190        self,
 4191        bind_interface=None,
 4192        database=None,
 4193        egress_filter=None,
 4194        healthy=None,
 4195        hostname=None,
 4196        id=None,
 4197        name=None,
 4198        password=None,
 4199        port=None,
 4200        port_override=None,
 4201        secret_store_id=None,
 4202        tags=None,
 4203        username=None,
 4204    ):
 4205        self.bind_interface = bind_interface if bind_interface is not None else ''
 4206        '''
 4207         Bind interface
 4208        '''
 4209        self.database = database if database is not None else ''
 4210        self.egress_filter = egress_filter if egress_filter is not None else ''
 4211        '''
 4212         A filter applied to the routing logic to pin datasource to nodes.
 4213        '''
 4214        self.healthy = healthy if healthy is not None else False
 4215        '''
 4216         True if the datasource is reachable and the credentials are valid.
 4217        '''
 4218        self.hostname = hostname if hostname is not None else ''
 4219        self.id = id if id is not None else ''
 4220        '''
 4221         Unique identifier of the Resource.
 4222        '''
 4223        self.name = name if name is not None else ''
 4224        '''
 4225         Unique human-readable name of the Resource.
 4226        '''
 4227        self.password = password if password is not None else ''
 4228        self.port = port if port is not None else 0
 4229        self.port_override = port_override if port_override is not None else 0
 4230        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4231        '''
 4232         ID of the secret store containing credentials for this resource, if any.
 4233        '''
 4234        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4235        '''
 4236         Tags is a map of key, value pairs.
 4237        '''
 4238        self.username = username if username is not None else ''
 4239
 4240    def __repr__(self):
 4241        return '<sdm.DB2LUW ' + \
 4242            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4243            'database: ' + repr(self.database) + ' ' +\
 4244            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4245            'healthy: ' + repr(self.healthy) + ' ' +\
 4246            'hostname: ' + repr(self.hostname) + ' ' +\
 4247            'id: ' + repr(self.id) + ' ' +\
 4248            'name: ' + repr(self.name) + ' ' +\
 4249            'password: ' + repr(self.password) + ' ' +\
 4250            'port: ' + repr(self.port) + ' ' +\
 4251            'port_override: ' + repr(self.port_override) + ' ' +\
 4252            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4253            'tags: ' + repr(self.tags) + ' ' +\
 4254            'username: ' + repr(self.username) + ' ' +\
 4255            '>'
 4256
 4257    def to_dict(self):
 4258        return {
 4259            'bind_interface': self.bind_interface,
 4260            'database': self.database,
 4261            'egress_filter': self.egress_filter,
 4262            'healthy': self.healthy,
 4263            'hostname': self.hostname,
 4264            'id': self.id,
 4265            'name': self.name,
 4266            'password': self.password,
 4267            'port': self.port,
 4268            'port_override': self.port_override,
 4269            'secret_store_id': self.secret_store_id,
 4270            'tags': self.tags,
 4271            'username': self.username,
 4272        }
 4273
 4274    @classmethod
 4275    def from_dict(cls, d):
 4276        return cls(
 4277            bind_interface=d.get('bind_interface'),
 4278            database=d.get('database'),
 4279            egress_filter=d.get('egress_filter'),
 4280            healthy=d.get('healthy'),
 4281            hostname=d.get('hostname'),
 4282            id=d.get('id'),
 4283            name=d.get('name'),
 4284            password=d.get('password'),
 4285            port=d.get('port'),
 4286            port_override=d.get('port_override'),
 4287            secret_store_id=d.get('secret_store_id'),
 4288            tags=d.get('tags'),
 4289            username=d.get('username'),
 4290        )
 4291
 4292
 4293class DeleteResponseMetadata:
 4294    '''
 4295         DeleteResponseMetadata is reserved for future use.
 4296    '''
 4297    __slots__ = []
 4298
 4299    def __init__(self, ):
 4300        pass
 4301
 4302    def __repr__(self):
 4303        return '<sdm.DeleteResponseMetadata ' + \
 4304            '>'
 4305
 4306    def to_dict(self):
 4307        return {}
 4308
 4309    @classmethod
 4310    def from_dict(cls, d):
 4311        return cls()
 4312
 4313
 4314class DelineaStore:
 4315    '''
 4316    DelineaStore is currently unstable, and its API may change, or it may be removed,
 4317    without a major version bump.
 4318    '''
 4319    __slots__ = [
 4320        'id',
 4321        'name',
 4322        'server_url',
 4323        'tags',
 4324        'tenant_name',
 4325    ]
 4326
 4327    def __init__(
 4328        self,
 4329        id=None,
 4330        name=None,
 4331        server_url=None,
 4332        tags=None,
 4333        tenant_name=None,
 4334    ):
 4335        self.id = id if id is not None else ''
 4336        '''
 4337         Unique identifier of the SecretStore.
 4338        '''
 4339        self.name = name if name is not None else ''
 4340        '''
 4341         Unique human-readable name of the SecretStore.
 4342        '''
 4343        self.server_url = server_url if server_url is not None else ''
 4344        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4345        '''
 4346         Tags is a map of key, value pairs.
 4347        '''
 4348        self.tenant_name = tenant_name if tenant_name is not None else ''
 4349
 4350    def __repr__(self):
 4351        return '<sdm.DelineaStore ' + \
 4352            'id: ' + repr(self.id) + ' ' +\
 4353            'name: ' + repr(self.name) + ' ' +\
 4354            'server_url: ' + repr(self.server_url) + ' ' +\
 4355            'tags: ' + repr(self.tags) + ' ' +\
 4356            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
 4357            '>'
 4358
 4359    def to_dict(self):
 4360        return {
 4361            'id': self.id,
 4362            'name': self.name,
 4363            'server_url': self.server_url,
 4364            'tags': self.tags,
 4365            'tenant_name': self.tenant_name,
 4366        }
 4367
 4368    @classmethod
 4369    def from_dict(cls, d):
 4370        return cls(
 4371            id=d.get('id'),
 4372            name=d.get('name'),
 4373            server_url=d.get('server_url'),
 4374            tags=d.get('tags'),
 4375            tenant_name=d.get('tenant_name'),
 4376        )
 4377
 4378
 4379class DocumentDBHost:
 4380    __slots__ = [
 4381        'auth_database',
 4382        'bind_interface',
 4383        'egress_filter',
 4384        'healthy',
 4385        'hostname',
 4386        'id',
 4387        'name',
 4388        'password',
 4389        'port',
 4390        'port_override',
 4391        'secret_store_id',
 4392        'tags',
 4393        'username',
 4394    ]
 4395
 4396    def __init__(
 4397        self,
 4398        auth_database=None,
 4399        bind_interface=None,
 4400        egress_filter=None,
 4401        healthy=None,
 4402        hostname=None,
 4403        id=None,
 4404        name=None,
 4405        password=None,
 4406        port=None,
 4407        port_override=None,
 4408        secret_store_id=None,
 4409        tags=None,
 4410        username=None,
 4411    ):
 4412        self.auth_database = auth_database if auth_database is not None else ''
 4413        self.bind_interface = bind_interface if bind_interface is not None else ''
 4414        '''
 4415         Bind interface
 4416        '''
 4417        self.egress_filter = egress_filter if egress_filter is not None else ''
 4418        '''
 4419         A filter applied to the routing logic to pin datasource to nodes.
 4420        '''
 4421        self.healthy = healthy if healthy is not None else False
 4422        '''
 4423         True if the datasource is reachable and the credentials are valid.
 4424        '''
 4425        self.hostname = hostname if hostname is not None else ''
 4426        self.id = id if id is not None else ''
 4427        '''
 4428         Unique identifier of the Resource.
 4429        '''
 4430        self.name = name if name is not None else ''
 4431        '''
 4432         Unique human-readable name of the Resource.
 4433        '''
 4434        self.password = password if password is not None else ''
 4435        self.port = port if port is not None else 0
 4436        self.port_override = port_override if port_override is not None else 0
 4437        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4438        '''
 4439         ID of the secret store containing credentials for this resource, if any.
 4440        '''
 4441        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4442        '''
 4443         Tags is a map of key, value pairs.
 4444        '''
 4445        self.username = username if username is not None else ''
 4446
 4447    def __repr__(self):
 4448        return '<sdm.DocumentDBHost ' + \
 4449            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4450            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4451            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4452            'healthy: ' + repr(self.healthy) + ' ' +\
 4453            'hostname: ' + repr(self.hostname) + ' ' +\
 4454            'id: ' + repr(self.id) + ' ' +\
 4455            'name: ' + repr(self.name) + ' ' +\
 4456            'password: ' + repr(self.password) + ' ' +\
 4457            'port: ' + repr(self.port) + ' ' +\
 4458            'port_override: ' + repr(self.port_override) + ' ' +\
 4459            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4460            'tags: ' + repr(self.tags) + ' ' +\
 4461            'username: ' + repr(self.username) + ' ' +\
 4462            '>'
 4463
 4464    def to_dict(self):
 4465        return {
 4466            'auth_database': self.auth_database,
 4467            'bind_interface': self.bind_interface,
 4468            'egress_filter': self.egress_filter,
 4469            'healthy': self.healthy,
 4470            'hostname': self.hostname,
 4471            'id': self.id,
 4472            'name': self.name,
 4473            'password': self.password,
 4474            'port': self.port,
 4475            'port_override': self.port_override,
 4476            'secret_store_id': self.secret_store_id,
 4477            'tags': self.tags,
 4478            'username': self.username,
 4479        }
 4480
 4481    @classmethod
 4482    def from_dict(cls, d):
 4483        return cls(
 4484            auth_database=d.get('auth_database'),
 4485            bind_interface=d.get('bind_interface'),
 4486            egress_filter=d.get('egress_filter'),
 4487            healthy=d.get('healthy'),
 4488            hostname=d.get('hostname'),
 4489            id=d.get('id'),
 4490            name=d.get('name'),
 4491            password=d.get('password'),
 4492            port=d.get('port'),
 4493            port_override=d.get('port_override'),
 4494            secret_store_id=d.get('secret_store_id'),
 4495            tags=d.get('tags'),
 4496            username=d.get('username'),
 4497        )
 4498
 4499
 4500class DocumentDBReplicaSet:
 4501    __slots__ = [
 4502        'auth_database',
 4503        'bind_interface',
 4504        'connect_to_replica',
 4505        'egress_filter',
 4506        'healthy',
 4507        'hostname',
 4508        'id',
 4509        'name',
 4510        'password',
 4511        'port_override',
 4512        'replica_set',
 4513        'secret_store_id',
 4514        'tags',
 4515        'username',
 4516    ]
 4517
 4518    def __init__(
 4519        self,
 4520        auth_database=None,
 4521        bind_interface=None,
 4522        connect_to_replica=None,
 4523        egress_filter=None,
 4524        healthy=None,
 4525        hostname=None,
 4526        id=None,
 4527        name=None,
 4528        password=None,
 4529        port_override=None,
 4530        replica_set=None,
 4531        secret_store_id=None,
 4532        tags=None,
 4533        username=None,
 4534    ):
 4535        self.auth_database = auth_database if auth_database is not None else ''
 4536        self.bind_interface = bind_interface if bind_interface is not None else ''
 4537        '''
 4538         Bind interface
 4539        '''
 4540        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4541        self.egress_filter = egress_filter if egress_filter is not None else ''
 4542        '''
 4543         A filter applied to the routing logic to pin datasource to nodes.
 4544        '''
 4545        self.healthy = healthy if healthy is not None else False
 4546        '''
 4547         True if the datasource is reachable and the credentials are valid.
 4548        '''
 4549        self.hostname = hostname if hostname is not None else ''
 4550        '''
 4551         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4552        '''
 4553        self.id = id if id is not None else ''
 4554        '''
 4555         Unique identifier of the Resource.
 4556        '''
 4557        self.name = name if name is not None else ''
 4558        '''
 4559         Unique human-readable name of the Resource.
 4560        '''
 4561        self.password = password if password is not None else ''
 4562        self.port_override = port_override if port_override is not None else 0
 4563        self.replica_set = replica_set if replica_set is not None else ''
 4564        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4565        '''
 4566         ID of the secret store containing credentials for this resource, if any.
 4567        '''
 4568        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4569        '''
 4570         Tags is a map of key, value pairs.
 4571        '''
 4572        self.username = username if username is not None else ''
 4573
 4574    def __repr__(self):
 4575        return '<sdm.DocumentDBReplicaSet ' + \
 4576            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4577            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4578            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4579            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4580            'healthy: ' + repr(self.healthy) + ' ' +\
 4581            'hostname: ' + repr(self.hostname) + ' ' +\
 4582            'id: ' + repr(self.id) + ' ' +\
 4583            'name: ' + repr(self.name) + ' ' +\
 4584            'password: ' + repr(self.password) + ' ' +\
 4585            'port_override: ' + repr(self.port_override) + ' ' +\
 4586            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4587            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4588            'tags: ' + repr(self.tags) + ' ' +\
 4589            'username: ' + repr(self.username) + ' ' +\
 4590            '>'
 4591
 4592    def to_dict(self):
 4593        return {
 4594            'auth_database': self.auth_database,
 4595            'bind_interface': self.bind_interface,
 4596            'connect_to_replica': self.connect_to_replica,
 4597            'egress_filter': self.egress_filter,
 4598            'healthy': self.healthy,
 4599            'hostname': self.hostname,
 4600            'id': self.id,
 4601            'name': self.name,
 4602            'password': self.password,
 4603            'port_override': self.port_override,
 4604            'replica_set': self.replica_set,
 4605            'secret_store_id': self.secret_store_id,
 4606            'tags': self.tags,
 4607            'username': self.username,
 4608        }
 4609
 4610    @classmethod
 4611    def from_dict(cls, d):
 4612        return cls(
 4613            auth_database=d.get('auth_database'),
 4614            bind_interface=d.get('bind_interface'),
 4615            connect_to_replica=d.get('connect_to_replica'),
 4616            egress_filter=d.get('egress_filter'),
 4617            healthy=d.get('healthy'),
 4618            hostname=d.get('hostname'),
 4619            id=d.get('id'),
 4620            name=d.get('name'),
 4621            password=d.get('password'),
 4622            port_override=d.get('port_override'),
 4623            replica_set=d.get('replica_set'),
 4624            secret_store_id=d.get('secret_store_id'),
 4625            tags=d.get('tags'),
 4626            username=d.get('username'),
 4627        )
 4628
 4629
 4630class Druid:
 4631    __slots__ = [
 4632        'bind_interface',
 4633        'egress_filter',
 4634        'healthy',
 4635        'hostname',
 4636        'id',
 4637        'name',
 4638        'password',
 4639        'port',
 4640        'port_override',
 4641        'secret_store_id',
 4642        'tags',
 4643        'username',
 4644    ]
 4645
 4646    def __init__(
 4647        self,
 4648        bind_interface=None,
 4649        egress_filter=None,
 4650        healthy=None,
 4651        hostname=None,
 4652        id=None,
 4653        name=None,
 4654        password=None,
 4655        port=None,
 4656        port_override=None,
 4657        secret_store_id=None,
 4658        tags=None,
 4659        username=None,
 4660    ):
 4661        self.bind_interface = bind_interface if bind_interface is not None else ''
 4662        '''
 4663         Bind interface
 4664        '''
 4665        self.egress_filter = egress_filter if egress_filter is not None else ''
 4666        '''
 4667         A filter applied to the routing logic to pin datasource to nodes.
 4668        '''
 4669        self.healthy = healthy if healthy is not None else False
 4670        '''
 4671         True if the datasource is reachable and the credentials are valid.
 4672        '''
 4673        self.hostname = hostname if hostname is not None else ''
 4674        self.id = id if id is not None else ''
 4675        '''
 4676         Unique identifier of the Resource.
 4677        '''
 4678        self.name = name if name is not None else ''
 4679        '''
 4680         Unique human-readable name of the Resource.
 4681        '''
 4682        self.password = password if password is not None else ''
 4683        self.port = port if port is not None else 0
 4684        self.port_override = port_override if port_override is not None else 0
 4685        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4686        '''
 4687         ID of the secret store containing credentials for this resource, if any.
 4688        '''
 4689        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4690        '''
 4691         Tags is a map of key, value pairs.
 4692        '''
 4693        self.username = username if username is not None else ''
 4694
 4695    def __repr__(self):
 4696        return '<sdm.Druid ' + \
 4697            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4698            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4699            'healthy: ' + repr(self.healthy) + ' ' +\
 4700            'hostname: ' + repr(self.hostname) + ' ' +\
 4701            'id: ' + repr(self.id) + ' ' +\
 4702            'name: ' + repr(self.name) + ' ' +\
 4703            'password: ' + repr(self.password) + ' ' +\
 4704            'port: ' + repr(self.port) + ' ' +\
 4705            'port_override: ' + repr(self.port_override) + ' ' +\
 4706            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4707            'tags: ' + repr(self.tags) + ' ' +\
 4708            'username: ' + repr(self.username) + ' ' +\
 4709            '>'
 4710
 4711    def to_dict(self):
 4712        return {
 4713            'bind_interface': self.bind_interface,
 4714            'egress_filter': self.egress_filter,
 4715            'healthy': self.healthy,
 4716            'hostname': self.hostname,
 4717            'id': self.id,
 4718            'name': self.name,
 4719            'password': self.password,
 4720            'port': self.port,
 4721            'port_override': self.port_override,
 4722            'secret_store_id': self.secret_store_id,
 4723            'tags': self.tags,
 4724            'username': self.username,
 4725        }
 4726
 4727    @classmethod
 4728    def from_dict(cls, d):
 4729        return cls(
 4730            bind_interface=d.get('bind_interface'),
 4731            egress_filter=d.get('egress_filter'),
 4732            healthy=d.get('healthy'),
 4733            hostname=d.get('hostname'),
 4734            id=d.get('id'),
 4735            name=d.get('name'),
 4736            password=d.get('password'),
 4737            port=d.get('port'),
 4738            port_override=d.get('port_override'),
 4739            secret_store_id=d.get('secret_store_id'),
 4740            tags=d.get('tags'),
 4741            username=d.get('username'),
 4742        )
 4743
 4744
 4745class DynamoDB:
 4746    __slots__ = [
 4747        'access_key',
 4748        'bind_interface',
 4749        'egress_filter',
 4750        'endpoint',
 4751        'healthy',
 4752        'id',
 4753        'name',
 4754        'port_override',
 4755        'region',
 4756        'role_arn',
 4757        'role_external_id',
 4758        'secret_access_key',
 4759        'secret_store_id',
 4760        'tags',
 4761    ]
 4762
 4763    def __init__(
 4764        self,
 4765        access_key=None,
 4766        bind_interface=None,
 4767        egress_filter=None,
 4768        endpoint=None,
 4769        healthy=None,
 4770        id=None,
 4771        name=None,
 4772        port_override=None,
 4773        region=None,
 4774        role_arn=None,
 4775        role_external_id=None,
 4776        secret_access_key=None,
 4777        secret_store_id=None,
 4778        tags=None,
 4779    ):
 4780        self.access_key = access_key if access_key is not None else ''
 4781        self.bind_interface = bind_interface if bind_interface is not None else ''
 4782        '''
 4783         Bind interface
 4784        '''
 4785        self.egress_filter = egress_filter if egress_filter is not None else ''
 4786        '''
 4787         A filter applied to the routing logic to pin datasource to nodes.
 4788        '''
 4789        self.endpoint = endpoint if endpoint is not None else ''
 4790        self.healthy = healthy if healthy is not None else False
 4791        '''
 4792         True if the datasource is reachable and the credentials are valid.
 4793        '''
 4794        self.id = id if id is not None else ''
 4795        '''
 4796         Unique identifier of the Resource.
 4797        '''
 4798        self.name = name if name is not None else ''
 4799        '''
 4800         Unique human-readable name of the Resource.
 4801        '''
 4802        self.port_override = port_override if port_override is not None else 0
 4803        self.region = region if region is not None else ''
 4804        self.role_arn = role_arn if role_arn is not None else ''
 4805        self.role_external_id = role_external_id if role_external_id is not None else ''
 4806        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4807        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4808        '''
 4809         ID of the secret store containing credentials for this resource, if any.
 4810        '''
 4811        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4812        '''
 4813         Tags is a map of key, value pairs.
 4814        '''
 4815
 4816    def __repr__(self):
 4817        return '<sdm.DynamoDB ' + \
 4818            'access_key: ' + repr(self.access_key) + ' ' +\
 4819            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4820            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4821            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4822            'healthy: ' + repr(self.healthy) + ' ' +\
 4823            'id: ' + repr(self.id) + ' ' +\
 4824            'name: ' + repr(self.name) + ' ' +\
 4825            'port_override: ' + repr(self.port_override) + ' ' +\
 4826            'region: ' + repr(self.region) + ' ' +\
 4827            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4828            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4829            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4830            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4831            'tags: ' + repr(self.tags) + ' ' +\
 4832            '>'
 4833
 4834    def to_dict(self):
 4835        return {
 4836            'access_key': self.access_key,
 4837            'bind_interface': self.bind_interface,
 4838            'egress_filter': self.egress_filter,
 4839            'endpoint': self.endpoint,
 4840            'healthy': self.healthy,
 4841            'id': self.id,
 4842            'name': self.name,
 4843            'port_override': self.port_override,
 4844            'region': self.region,
 4845            'role_arn': self.role_arn,
 4846            'role_external_id': self.role_external_id,
 4847            'secret_access_key': self.secret_access_key,
 4848            'secret_store_id': self.secret_store_id,
 4849            'tags': self.tags,
 4850        }
 4851
 4852    @classmethod
 4853    def from_dict(cls, d):
 4854        return cls(
 4855            access_key=d.get('access_key'),
 4856            bind_interface=d.get('bind_interface'),
 4857            egress_filter=d.get('egress_filter'),
 4858            endpoint=d.get('endpoint'),
 4859            healthy=d.get('healthy'),
 4860            id=d.get('id'),
 4861            name=d.get('name'),
 4862            port_override=d.get('port_override'),
 4863            region=d.get('region'),
 4864            role_arn=d.get('role_arn'),
 4865            role_external_id=d.get('role_external_id'),
 4866            secret_access_key=d.get('secret_access_key'),
 4867            secret_store_id=d.get('secret_store_id'),
 4868            tags=d.get('tags'),
 4869        )
 4870
 4871
 4872class Elastic:
 4873    __slots__ = [
 4874        'bind_interface',
 4875        'egress_filter',
 4876        'healthy',
 4877        'hostname',
 4878        'id',
 4879        'name',
 4880        'password',
 4881        'port',
 4882        'port_override',
 4883        'secret_store_id',
 4884        'tags',
 4885        'tls_required',
 4886        'username',
 4887    ]
 4888
 4889    def __init__(
 4890        self,
 4891        bind_interface=None,
 4892        egress_filter=None,
 4893        healthy=None,
 4894        hostname=None,
 4895        id=None,
 4896        name=None,
 4897        password=None,
 4898        port=None,
 4899        port_override=None,
 4900        secret_store_id=None,
 4901        tags=None,
 4902        tls_required=None,
 4903        username=None,
 4904    ):
 4905        self.bind_interface = bind_interface if bind_interface is not None else ''
 4906        '''
 4907         Bind interface
 4908        '''
 4909        self.egress_filter = egress_filter if egress_filter is not None else ''
 4910        '''
 4911         A filter applied to the routing logic to pin datasource to nodes.
 4912        '''
 4913        self.healthy = healthy if healthy is not None else False
 4914        '''
 4915         True if the datasource is reachable and the credentials are valid.
 4916        '''
 4917        self.hostname = hostname if hostname is not None else ''
 4918        self.id = id if id is not None else ''
 4919        '''
 4920         Unique identifier of the Resource.
 4921        '''
 4922        self.name = name if name is not None else ''
 4923        '''
 4924         Unique human-readable name of the Resource.
 4925        '''
 4926        self.password = password if password is not None else ''
 4927        self.port = port if port is not None else 0
 4928        self.port_override = port_override if port_override is not None else 0
 4929        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4930        '''
 4931         ID of the secret store containing credentials for this resource, if any.
 4932        '''
 4933        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4934        '''
 4935         Tags is a map of key, value pairs.
 4936        '''
 4937        self.tls_required = tls_required if tls_required is not None else False
 4938        self.username = username if username is not None else ''
 4939
 4940    def __repr__(self):
 4941        return '<sdm.Elastic ' + \
 4942            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4943            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4944            'healthy: ' + repr(self.healthy) + ' ' +\
 4945            'hostname: ' + repr(self.hostname) + ' ' +\
 4946            'id: ' + repr(self.id) + ' ' +\
 4947            'name: ' + repr(self.name) + ' ' +\
 4948            'password: ' + repr(self.password) + ' ' +\
 4949            'port: ' + repr(self.port) + ' ' +\
 4950            'port_override: ' + repr(self.port_override) + ' ' +\
 4951            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4952            'tags: ' + repr(self.tags) + ' ' +\
 4953            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4954            'username: ' + repr(self.username) + ' ' +\
 4955            '>'
 4956
 4957    def to_dict(self):
 4958        return {
 4959            'bind_interface': self.bind_interface,
 4960            'egress_filter': self.egress_filter,
 4961            'healthy': self.healthy,
 4962            'hostname': self.hostname,
 4963            'id': self.id,
 4964            'name': self.name,
 4965            'password': self.password,
 4966            'port': self.port,
 4967            'port_override': self.port_override,
 4968            'secret_store_id': self.secret_store_id,
 4969            'tags': self.tags,
 4970            'tls_required': self.tls_required,
 4971            'username': self.username,
 4972        }
 4973
 4974    @classmethod
 4975    def from_dict(cls, d):
 4976        return cls(
 4977            bind_interface=d.get('bind_interface'),
 4978            egress_filter=d.get('egress_filter'),
 4979            healthy=d.get('healthy'),
 4980            hostname=d.get('hostname'),
 4981            id=d.get('id'),
 4982            name=d.get('name'),
 4983            password=d.get('password'),
 4984            port=d.get('port'),
 4985            port_override=d.get('port_override'),
 4986            secret_store_id=d.get('secret_store_id'),
 4987            tags=d.get('tags'),
 4988            tls_required=d.get('tls_required'),
 4989            username=d.get('username'),
 4990        )
 4991
 4992
 4993class ElasticacheRedis:
 4994    __slots__ = [
 4995        'bind_interface',
 4996        'egress_filter',
 4997        'healthy',
 4998        'hostname',
 4999        'id',
 5000        'name',
 5001        'password',
 5002        'port',
 5003        'port_override',
 5004        'secret_store_id',
 5005        'tags',
 5006        'tls_required',
 5007    ]
 5008
 5009    def __init__(
 5010        self,
 5011        bind_interface=None,
 5012        egress_filter=None,
 5013        healthy=None,
 5014        hostname=None,
 5015        id=None,
 5016        name=None,
 5017        password=None,
 5018        port=None,
 5019        port_override=None,
 5020        secret_store_id=None,
 5021        tags=None,
 5022        tls_required=None,
 5023    ):
 5024        self.bind_interface = bind_interface if bind_interface is not None else ''
 5025        '''
 5026         Bind interface
 5027        '''
 5028        self.egress_filter = egress_filter if egress_filter is not None else ''
 5029        '''
 5030         A filter applied to the routing logic to pin datasource to nodes.
 5031        '''
 5032        self.healthy = healthy if healthy is not None else False
 5033        '''
 5034         True if the datasource is reachable and the credentials are valid.
 5035        '''
 5036        self.hostname = hostname if hostname is not None else ''
 5037        self.id = id if id is not None else ''
 5038        '''
 5039         Unique identifier of the Resource.
 5040        '''
 5041        self.name = name if name is not None else ''
 5042        '''
 5043         Unique human-readable name of the Resource.
 5044        '''
 5045        self.password = password if password is not None else ''
 5046        self.port = port if port is not None else 0
 5047        self.port_override = port_override if port_override is not None else 0
 5048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5049        '''
 5050         ID of the secret store containing credentials for this resource, if any.
 5051        '''
 5052        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5053        '''
 5054         Tags is a map of key, value pairs.
 5055        '''
 5056        self.tls_required = tls_required if tls_required is not None else False
 5057
 5058    def __repr__(self):
 5059        return '<sdm.ElasticacheRedis ' + \
 5060            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5061            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5062            'healthy: ' + repr(self.healthy) + ' ' +\
 5063            'hostname: ' + repr(self.hostname) + ' ' +\
 5064            'id: ' + repr(self.id) + ' ' +\
 5065            'name: ' + repr(self.name) + ' ' +\
 5066            'password: ' + repr(self.password) + ' ' +\
 5067            'port: ' + repr(self.port) + ' ' +\
 5068            'port_override: ' + repr(self.port_override) + ' ' +\
 5069            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5070            'tags: ' + repr(self.tags) + ' ' +\
 5071            'tls_required: ' + repr(self.tls_required) + ' ' +\
 5072            '>'
 5073
 5074    def to_dict(self):
 5075        return {
 5076            'bind_interface': self.bind_interface,
 5077            'egress_filter': self.egress_filter,
 5078            'healthy': self.healthy,
 5079            'hostname': self.hostname,
 5080            'id': self.id,
 5081            'name': self.name,
 5082            'password': self.password,
 5083            'port': self.port,
 5084            'port_override': self.port_override,
 5085            'secret_store_id': self.secret_store_id,
 5086            'tags': self.tags,
 5087            'tls_required': self.tls_required,
 5088        }
 5089
 5090    @classmethod
 5091    def from_dict(cls, d):
 5092        return cls(
 5093            bind_interface=d.get('bind_interface'),
 5094            egress_filter=d.get('egress_filter'),
 5095            healthy=d.get('healthy'),
 5096            hostname=d.get('hostname'),
 5097            id=d.get('id'),
 5098            name=d.get('name'),
 5099            password=d.get('password'),
 5100            port=d.get('port'),
 5101            port_override=d.get('port_override'),
 5102            secret_store_id=d.get('secret_store_id'),
 5103            tags=d.get('tags'),
 5104            tls_required=d.get('tls_required'),
 5105        )
 5106
 5107
 5108class GCP:
 5109    __slots__ = [
 5110        'bind_interface',
 5111        'egress_filter',
 5112        'healthy',
 5113        'id',
 5114        'keyfile',
 5115        'name',
 5116        'scopes',
 5117        'secret_store_id',
 5118        'tags',
 5119    ]
 5120
 5121    def __init__(
 5122        self,
 5123        bind_interface=None,
 5124        egress_filter=None,
 5125        healthy=None,
 5126        id=None,
 5127        keyfile=None,
 5128        name=None,
 5129        scopes=None,
 5130        secret_store_id=None,
 5131        tags=None,
 5132    ):
 5133        self.bind_interface = bind_interface if bind_interface is not None else ''
 5134        '''
 5135         Bind interface
 5136        '''
 5137        self.egress_filter = egress_filter if egress_filter is not None else ''
 5138        '''
 5139         A filter applied to the routing logic to pin datasource to nodes.
 5140        '''
 5141        self.healthy = healthy if healthy is not None else False
 5142        '''
 5143         True if the datasource is reachable and the credentials are valid.
 5144        '''
 5145        self.id = id if id is not None else ''
 5146        '''
 5147         Unique identifier of the Resource.
 5148        '''
 5149        self.keyfile = keyfile if keyfile is not None else ''
 5150        self.name = name if name is not None else ''
 5151        '''
 5152         Unique human-readable name of the Resource.
 5153        '''
 5154        self.scopes = scopes if scopes is not None else ''
 5155        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5156        '''
 5157         ID of the secret store containing credentials for this resource, if any.
 5158        '''
 5159        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5160        '''
 5161         Tags is a map of key, value pairs.
 5162        '''
 5163
 5164    def __repr__(self):
 5165        return '<sdm.GCP ' + \
 5166            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5167            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5168            'healthy: ' + repr(self.healthy) + ' ' +\
 5169            'id: ' + repr(self.id) + ' ' +\
 5170            'keyfile: ' + repr(self.keyfile) + ' ' +\
 5171            'name: ' + repr(self.name) + ' ' +\
 5172            'scopes: ' + repr(self.scopes) + ' ' +\
 5173            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5174            'tags: ' + repr(self.tags) + ' ' +\
 5175            '>'
 5176
 5177    def to_dict(self):
 5178        return {
 5179            'bind_interface': self.bind_interface,
 5180            'egress_filter': self.egress_filter,
 5181            'healthy': self.healthy,
 5182            'id': self.id,
 5183            'keyfile': self.keyfile,
 5184            'name': self.name,
 5185            'scopes': self.scopes,
 5186            'secret_store_id': self.secret_store_id,
 5187            'tags': self.tags,
 5188        }
 5189
 5190    @classmethod
 5191    def from_dict(cls, d):
 5192        return cls(
 5193            bind_interface=d.get('bind_interface'),
 5194            egress_filter=d.get('egress_filter'),
 5195            healthy=d.get('healthy'),
 5196            id=d.get('id'),
 5197            keyfile=d.get('keyfile'),
 5198            name=d.get('name'),
 5199            scopes=d.get('scopes'),
 5200            secret_store_id=d.get('secret_store_id'),
 5201            tags=d.get('tags'),
 5202        )
 5203
 5204
 5205class GCPStore:
 5206    __slots__ = [
 5207        'id',
 5208        'name',
 5209        'projectid',
 5210        'tags',
 5211    ]
 5212
 5213    def __init__(
 5214        self,
 5215        id=None,
 5216        name=None,
 5217        projectid=None,
 5218        tags=None,
 5219    ):
 5220        self.id = id if id is not None else ''
 5221        '''
 5222         Unique identifier of the SecretStore.
 5223        '''
 5224        self.name = name if name is not None else ''
 5225        '''
 5226         Unique human-readable name of the SecretStore.
 5227        '''
 5228        self.projectid = projectid if projectid is not None else ''
 5229        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5230        '''
 5231         Tags is a map of key, value pairs.
 5232        '''
 5233
 5234    def __repr__(self):
 5235        return '<sdm.GCPStore ' + \
 5236            'id: ' + repr(self.id) + ' ' +\
 5237            'name: ' + repr(self.name) + ' ' +\
 5238            'projectid: ' + repr(self.projectid) + ' ' +\
 5239            'tags: ' + repr(self.tags) + ' ' +\
 5240            '>'
 5241
 5242    def to_dict(self):
 5243        return {
 5244            'id': self.id,
 5245            'name': self.name,
 5246            'projectid': self.projectid,
 5247            'tags': self.tags,
 5248        }
 5249
 5250    @classmethod
 5251    def from_dict(cls, d):
 5252        return cls(
 5253            id=d.get('id'),
 5254            name=d.get('name'),
 5255            projectid=d.get('projectid'),
 5256            tags=d.get('tags'),
 5257        )
 5258
 5259
 5260class Gateway:
 5261    '''
 5262         Gateway represents a StrongDM CLI installation running in gateway mode.
 5263    '''
 5264    __slots__ = [
 5265        'bind_address',
 5266        'device',
 5267        'gateway_filter',
 5268        'id',
 5269        'listen_address',
 5270        'location',
 5271        'name',
 5272        'state',
 5273        'tags',
 5274        'version',
 5275    ]
 5276
 5277    def __init__(
 5278        self,
 5279        bind_address=None,
 5280        device=None,
 5281        gateway_filter=None,
 5282        id=None,
 5283        listen_address=None,
 5284        location=None,
 5285        name=None,
 5286        state=None,
 5287        tags=None,
 5288        version=None,
 5289    ):
 5290        self.bind_address = bind_address if bind_address is not None else ''
 5291        '''
 5292         The hostname/port tuple which the gateway daemon will bind to.
 5293         If not provided on create, set to "0.0.0.0:listen_address_port".
 5294        '''
 5295        self.device = device if device is not None else ''
 5296        '''
 5297         Device is a read only device name uploaded by the gateway process when 
 5298         it comes online.
 5299        '''
 5300        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 5301        '''
 5302         GatewayFilter can be used to restrict the peering between relays and
 5303         gateways.
 5304        '''
 5305        self.id = id if id is not None else ''
 5306        '''
 5307         Unique identifier of the Gateway.
 5308        '''
 5309        self.listen_address = listen_address if listen_address is not None else ''
 5310        '''
 5311         The public hostname/port tuple at which the gateway will be accessible to clients.
 5312        '''
 5313        self.location = location if location is not None else ''
 5314        '''
 5315         Location is a read only network location uploaded by the gateway process
 5316         when it comes online.
 5317        '''
 5318        self.name = name if name is not None else ''
 5319        '''
 5320         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 5321        '''
 5322        self.state = state if state is not None else ''
 5323        '''
 5324         The current state of the gateway. One of: "new", "verifying_restart",
 5325         "restarting", "started", "stopped", "dead", "unknown"
 5326        '''
 5327        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5328        '''
 5329         Tags is a map of key, value pairs.
 5330        '''
 5331        self.version = version if version is not None else ''
 5332        '''
 5333         Version is a read only sdm binary version uploaded by the gateway process
 5334         when it comes online.
 5335        '''
 5336
 5337    def __repr__(self):
 5338        return '<sdm.Gateway ' + \
 5339            'bind_address: ' + repr(self.bind_address) + ' ' +\
 5340            'device: ' + repr(self.device) + ' ' +\
 5341            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 5342            'id: ' + repr(self.id) + ' ' +\
 5343            'listen_address: ' + repr(self.listen_address) + ' ' +\
 5344            'location: ' + repr(self.location) + ' ' +\
 5345            'name: ' + repr(self.name) + ' ' +\
 5346            'state: ' + repr(self.state) + ' ' +\
 5347            'tags: ' + repr(self.tags) + ' ' +\
 5348            'version: ' + repr(self.version) + ' ' +\
 5349            '>'
 5350
 5351    def to_dict(self):
 5352        return {
 5353            'bind_address': self.bind_address,
 5354            'device': self.device,
 5355            'gateway_filter': self.gateway_filter,
 5356            'id': self.id,
 5357            'listen_address': self.listen_address,
 5358            'location': self.location,
 5359            'name': self.name,
 5360            'state': self.state,
 5361            'tags': self.tags,
 5362            'version': self.version,
 5363        }
 5364
 5365    @classmethod
 5366    def from_dict(cls, d):
 5367        return cls(
 5368            bind_address=d.get('bind_address'),
 5369            device=d.get('device'),
 5370            gateway_filter=d.get('gateway_filter'),
 5371            id=d.get('id'),
 5372            listen_address=d.get('listen_address'),
 5373            location=d.get('location'),
 5374            name=d.get('name'),
 5375            state=d.get('state'),
 5376            tags=d.get('tags'),
 5377            version=d.get('version'),
 5378        )
 5379
 5380
 5381class GetResponseMetadata:
 5382    '''
 5383         GetResponseMetadata is reserved for future use.
 5384    '''
 5385    __slots__ = []
 5386
 5387    def __init__(self, ):
 5388        pass
 5389
 5390    def __repr__(self):
 5391        return '<sdm.GetResponseMetadata ' + \
 5392            '>'
 5393
 5394    def to_dict(self):
 5395        return {}
 5396
 5397    @classmethod
 5398    def from_dict(cls, d):
 5399        return cls()
 5400
 5401
 5402class GoogleGKE:
 5403    __slots__ = [
 5404        'bind_interface',
 5405        'certificate_authority',
 5406        'egress_filter',
 5407        'endpoint',
 5408        'healthcheck_namespace',
 5409        'healthy',
 5410        'id',
 5411        'name',
 5412        'remote_identity_group_id',
 5413        'remote_identity_healthcheck_username',
 5414        'secret_store_id',
 5415        'service_account_key',
 5416        'tags',
 5417    ]
 5418
 5419    def __init__(
 5420        self,
 5421        bind_interface=None,
 5422        certificate_authority=None,
 5423        egress_filter=None,
 5424        endpoint=None,
 5425        healthcheck_namespace=None,
 5426        healthy=None,
 5427        id=None,
 5428        name=None,
 5429        remote_identity_group_id=None,
 5430        remote_identity_healthcheck_username=None,
 5431        secret_store_id=None,
 5432        service_account_key=None,
 5433        tags=None,
 5434    ):
 5435        self.bind_interface = bind_interface if bind_interface is not None else ''
 5436        '''
 5437         Bind interface
 5438        '''
 5439        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5440        self.egress_filter = egress_filter if egress_filter is not None else ''
 5441        '''
 5442         A filter applied to the routing logic to pin datasource to nodes.
 5443        '''
 5444        self.endpoint = endpoint if endpoint is not None else ''
 5445        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5446        '''
 5447         The path used to check the health of your connection.  Defaults to `default`.
 5448        '''
 5449        self.healthy = healthy if healthy is not None else False
 5450        '''
 5451         True if the datasource is reachable and the credentials are valid.
 5452        '''
 5453        self.id = id if id is not None else ''
 5454        '''
 5455         Unique identifier of the Resource.
 5456        '''
 5457        self.name = name if name is not None else ''
 5458        '''
 5459         Unique human-readable name of the Resource.
 5460        '''
 5461        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5462        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5463        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5464        '''
 5465         ID of the secret store containing credentials for this resource, if any.
 5466        '''
 5467        self.service_account_key = service_account_key if service_account_key is not None else ''
 5468        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5469        '''
 5470         Tags is a map of key, value pairs.
 5471        '''
 5472
 5473    def __repr__(self):
 5474        return '<sdm.GoogleGKE ' + \
 5475            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5476            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5477            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5478            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5479            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5480            'healthy: ' + repr(self.healthy) + ' ' +\
 5481            'id: ' + repr(self.id) + ' ' +\
 5482            'name: ' + repr(self.name) + ' ' +\
 5483            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5484            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5485            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5486            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5487            'tags: ' + repr(self.tags) + ' ' +\
 5488            '>'
 5489
 5490    def to_dict(self):
 5491        return {
 5492            'bind_interface': self.bind_interface,
 5493            'certificate_authority': self.certificate_authority,
 5494            'egress_filter': self.egress_filter,
 5495            'endpoint': self.endpoint,
 5496            'healthcheck_namespace': self.healthcheck_namespace,
 5497            'healthy': self.healthy,
 5498            'id': self.id,
 5499            'name': self.name,
 5500            'remote_identity_group_id': self.remote_identity_group_id,
 5501            'remote_identity_healthcheck_username':
 5502            self.remote_identity_healthcheck_username,
 5503            'secret_store_id': self.secret_store_id,
 5504            'service_account_key': self.service_account_key,
 5505            'tags': self.tags,
 5506        }
 5507
 5508    @classmethod
 5509    def from_dict(cls, d):
 5510        return cls(
 5511            bind_interface=d.get('bind_interface'),
 5512            certificate_authority=d.get('certificate_authority'),
 5513            egress_filter=d.get('egress_filter'),
 5514            endpoint=d.get('endpoint'),
 5515            healthcheck_namespace=d.get('healthcheck_namespace'),
 5516            healthy=d.get('healthy'),
 5517            id=d.get('id'),
 5518            name=d.get('name'),
 5519            remote_identity_group_id=d.get('remote_identity_group_id'),
 5520            remote_identity_healthcheck_username=d.get(
 5521                'remote_identity_healthcheck_username'),
 5522            secret_store_id=d.get('secret_store_id'),
 5523            service_account_key=d.get('service_account_key'),
 5524            tags=d.get('tags'),
 5525        )
 5526
 5527
 5528class GoogleGKEUserImpersonation:
 5529    __slots__ = [
 5530        'bind_interface',
 5531        'certificate_authority',
 5532        'egress_filter',
 5533        'endpoint',
 5534        'healthcheck_namespace',
 5535        'healthy',
 5536        'id',
 5537        'name',
 5538        'secret_store_id',
 5539        'service_account_key',
 5540        'tags',
 5541    ]
 5542
 5543    def __init__(
 5544        self,
 5545        bind_interface=None,
 5546        certificate_authority=None,
 5547        egress_filter=None,
 5548        endpoint=None,
 5549        healthcheck_namespace=None,
 5550        healthy=None,
 5551        id=None,
 5552        name=None,
 5553        secret_store_id=None,
 5554        service_account_key=None,
 5555        tags=None,
 5556    ):
 5557        self.bind_interface = bind_interface if bind_interface is not None else ''
 5558        '''
 5559         Bind interface
 5560        '''
 5561        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5562        self.egress_filter = egress_filter if egress_filter is not None else ''
 5563        '''
 5564         A filter applied to the routing logic to pin datasource to nodes.
 5565        '''
 5566        self.endpoint = endpoint if endpoint is not None else ''
 5567        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5568        '''
 5569         The path used to check the health of your connection.  Defaults to `default`.
 5570        '''
 5571        self.healthy = healthy if healthy is not None else False
 5572        '''
 5573         True if the datasource is reachable and the credentials are valid.
 5574        '''
 5575        self.id = id if id is not None else ''
 5576        '''
 5577         Unique identifier of the Resource.
 5578        '''
 5579        self.name = name if name is not None else ''
 5580        '''
 5581         Unique human-readable name of the Resource.
 5582        '''
 5583        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5584        '''
 5585         ID of the secret store containing credentials for this resource, if any.
 5586        '''
 5587        self.service_account_key = service_account_key if service_account_key is not None else ''
 5588        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5589        '''
 5590         Tags is a map of key, value pairs.
 5591        '''
 5592
 5593    def __repr__(self):
 5594        return '<sdm.GoogleGKEUserImpersonation ' + \
 5595            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5596            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5597            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5598            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5599            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5600            'healthy: ' + repr(self.healthy) + ' ' +\
 5601            'id: ' + repr(self.id) + ' ' +\
 5602            'name: ' + repr(self.name) + ' ' +\
 5603            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5604            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5605            'tags: ' + repr(self.tags) + ' ' +\
 5606            '>'
 5607
 5608    def to_dict(self):
 5609        return {
 5610            'bind_interface': self.bind_interface,
 5611            'certificate_authority': self.certificate_authority,
 5612            'egress_filter': self.egress_filter,
 5613            'endpoint': self.endpoint,
 5614            'healthcheck_namespace': self.healthcheck_namespace,
 5615            'healthy': self.healthy,
 5616            'id': self.id,
 5617            'name': self.name,
 5618            'secret_store_id': self.secret_store_id,
 5619            'service_account_key': self.service_account_key,
 5620            'tags': self.tags,
 5621        }
 5622
 5623    @classmethod
 5624    def from_dict(cls, d):
 5625        return cls(
 5626            bind_interface=d.get('bind_interface'),
 5627            certificate_authority=d.get('certificate_authority'),
 5628            egress_filter=d.get('egress_filter'),
 5629            endpoint=d.get('endpoint'),
 5630            healthcheck_namespace=d.get('healthcheck_namespace'),
 5631            healthy=d.get('healthy'),
 5632            id=d.get('id'),
 5633            name=d.get('name'),
 5634            secret_store_id=d.get('secret_store_id'),
 5635            service_account_key=d.get('service_account_key'),
 5636            tags=d.get('tags'),
 5637        )
 5638
 5639
 5640class Greenplum:
 5641    __slots__ = [
 5642        'bind_interface',
 5643        'database',
 5644        'egress_filter',
 5645        'healthy',
 5646        'hostname',
 5647        'id',
 5648        'name',
 5649        'override_database',
 5650        'password',
 5651        'port',
 5652        'port_override',
 5653        'secret_store_id',
 5654        'tags',
 5655        'username',
 5656    ]
 5657
 5658    def __init__(
 5659        self,
 5660        bind_interface=None,
 5661        database=None,
 5662        egress_filter=None,
 5663        healthy=None,
 5664        hostname=None,
 5665        id=None,
 5666        name=None,
 5667        override_database=None,
 5668        password=None,
 5669        port=None,
 5670        port_override=None,
 5671        secret_store_id=None,
 5672        tags=None,
 5673        username=None,
 5674    ):
 5675        self.bind_interface = bind_interface if bind_interface is not None else ''
 5676        '''
 5677         Bind interface
 5678        '''
 5679        self.database = database if database is not None else ''
 5680        self.egress_filter = egress_filter if egress_filter is not None else ''
 5681        '''
 5682         A filter applied to the routing logic to pin datasource to nodes.
 5683        '''
 5684        self.healthy = healthy if healthy is not None else False
 5685        '''
 5686         True if the datasource is reachable and the credentials are valid.
 5687        '''
 5688        self.hostname = hostname if hostname is not None else ''
 5689        self.id = id if id is not None else ''
 5690        '''
 5691         Unique identifier of the Resource.
 5692        '''
 5693        self.name = name if name is not None else ''
 5694        '''
 5695         Unique human-readable name of the Resource.
 5696        '''
 5697        self.override_database = override_database if override_database is not None else False
 5698        self.password = password if password is not None else ''
 5699        self.port = port if port is not None else 0
 5700        self.port_override = port_override if port_override is not None else 0
 5701        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5702        '''
 5703         ID of the secret store containing credentials for this resource, if any.
 5704        '''
 5705        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5706        '''
 5707         Tags is a map of key, value pairs.
 5708        '''
 5709        self.username = username if username is not None else ''
 5710
 5711    def __repr__(self):
 5712        return '<sdm.Greenplum ' + \
 5713            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5714            'database: ' + repr(self.database) + ' ' +\
 5715            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5716            'healthy: ' + repr(self.healthy) + ' ' +\
 5717            'hostname: ' + repr(self.hostname) + ' ' +\
 5718            'id: ' + repr(self.id) + ' ' +\
 5719            'name: ' + repr(self.name) + ' ' +\
 5720            'override_database: ' + repr(self.override_database) + ' ' +\
 5721            'password: ' + repr(self.password) + ' ' +\
 5722            'port: ' + repr(self.port) + ' ' +\
 5723            'port_override: ' + repr(self.port_override) + ' ' +\
 5724            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5725            'tags: ' + repr(self.tags) + ' ' +\
 5726            'username: ' + repr(self.username) + ' ' +\
 5727            '>'
 5728
 5729    def to_dict(self):
 5730        return {
 5731            'bind_interface': self.bind_interface,
 5732            'database': self.database,
 5733            'egress_filter': self.egress_filter,
 5734            'healthy': self.healthy,
 5735            'hostname': self.hostname,
 5736            'id': self.id,
 5737            'name': self.name,
 5738            'override_database': self.override_database,
 5739            'password': self.password,
 5740            'port': self.port,
 5741            'port_override': self.port_override,
 5742            'secret_store_id': self.secret_store_id,
 5743            'tags': self.tags,
 5744            'username': self.username,
 5745        }
 5746
 5747    @classmethod
 5748    def from_dict(cls, d):
 5749        return cls(
 5750            bind_interface=d.get('bind_interface'),
 5751            database=d.get('database'),
 5752            egress_filter=d.get('egress_filter'),
 5753            healthy=d.get('healthy'),
 5754            hostname=d.get('hostname'),
 5755            id=d.get('id'),
 5756            name=d.get('name'),
 5757            override_database=d.get('override_database'),
 5758            password=d.get('password'),
 5759            port=d.get('port'),
 5760            port_override=d.get('port_override'),
 5761            secret_store_id=d.get('secret_store_id'),
 5762            tags=d.get('tags'),
 5763            username=d.get('username'),
 5764        )
 5765
 5766
 5767class HTTPAuth:
 5768    __slots__ = [
 5769        'auth_header',
 5770        'bind_interface',
 5771        'default_path',
 5772        'egress_filter',
 5773        'headers_blacklist',
 5774        'healthcheck_path',
 5775        'healthy',
 5776        'host_override',
 5777        'id',
 5778        'name',
 5779        'secret_store_id',
 5780        'subdomain',
 5781        'tags',
 5782        'url',
 5783    ]
 5784
 5785    def __init__(
 5786        self,
 5787        auth_header=None,
 5788        bind_interface=None,
 5789        default_path=None,
 5790        egress_filter=None,
 5791        headers_blacklist=None,
 5792        healthcheck_path=None,
 5793        healthy=None,
 5794        host_override=None,
 5795        id=None,
 5796        name=None,
 5797        secret_store_id=None,
 5798        subdomain=None,
 5799        tags=None,
 5800        url=None,
 5801    ):
 5802        self.auth_header = auth_header if auth_header is not None else ''
 5803        self.bind_interface = bind_interface if bind_interface is not None else ''
 5804        '''
 5805         Bind interface
 5806        '''
 5807        self.default_path = default_path if default_path is not None else ''
 5808        self.egress_filter = egress_filter if egress_filter is not None else ''
 5809        '''
 5810         A filter applied to the routing logic to pin datasource to nodes.
 5811        '''
 5812        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5813        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5814        self.healthy = healthy if healthy is not None else False
 5815        '''
 5816         True if the datasource is reachable and the credentials are valid.
 5817        '''
 5818        self.host_override = host_override if host_override is not None else ''
 5819        self.id = id if id is not None else ''
 5820        '''
 5821         Unique identifier of the Resource.
 5822        '''
 5823        self.name = name if name is not None else ''
 5824        '''
 5825         Unique human-readable name of the Resource.
 5826        '''
 5827        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5828        '''
 5829         ID of the secret store containing credentials for this resource, if any.
 5830        '''
 5831        self.subdomain = subdomain if subdomain is not None else ''
 5832        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5833        '''
 5834         Tags is a map of key, value pairs.
 5835        '''
 5836        self.url = url if url is not None else ''
 5837
 5838    def __repr__(self):
 5839        return '<sdm.HTTPAuth ' + \
 5840            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5841            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5842            'default_path: ' + repr(self.default_path) + ' ' +\
 5843            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5844            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5845            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5846            'healthy: ' + repr(self.healthy) + ' ' +\
 5847            'host_override: ' + repr(self.host_override) + ' ' +\
 5848            'id: ' + repr(self.id) + ' ' +\
 5849            'name: ' + repr(self.name) + ' ' +\
 5850            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5851            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5852            'tags: ' + repr(self.tags) + ' ' +\
 5853            'url: ' + repr(self.url) + ' ' +\
 5854            '>'
 5855
 5856    def to_dict(self):
 5857        return {
 5858            'auth_header': self.auth_header,
 5859            'bind_interface': self.bind_interface,
 5860            'default_path': self.default_path,
 5861            'egress_filter': self.egress_filter,
 5862            'headers_blacklist': self.headers_blacklist,
 5863            'healthcheck_path': self.healthcheck_path,
 5864            'healthy': self.healthy,
 5865            'host_override': self.host_override,
 5866            'id': self.id,
 5867            'name': self.name,
 5868            'secret_store_id': self.secret_store_id,
 5869            'subdomain': self.subdomain,
 5870            'tags': self.tags,
 5871            'url': self.url,
 5872        }
 5873
 5874    @classmethod
 5875    def from_dict(cls, d):
 5876        return cls(
 5877            auth_header=d.get('auth_header'),
 5878            bind_interface=d.get('bind_interface'),
 5879            default_path=d.get('default_path'),
 5880            egress_filter=d.get('egress_filter'),
 5881            headers_blacklist=d.get('headers_blacklist'),
 5882            healthcheck_path=d.get('healthcheck_path'),
 5883            healthy=d.get('healthy'),
 5884            host_override=d.get('host_override'),
 5885            id=d.get('id'),
 5886            name=d.get('name'),
 5887            secret_store_id=d.get('secret_store_id'),
 5888            subdomain=d.get('subdomain'),
 5889            tags=d.get('tags'),
 5890            url=d.get('url'),
 5891        )
 5892
 5893
 5894class HTTPBasicAuth:
 5895    __slots__ = [
 5896        'bind_interface',
 5897        'default_path',
 5898        'egress_filter',
 5899        'headers_blacklist',
 5900        'healthcheck_path',
 5901        'healthy',
 5902        'host_override',
 5903        'id',
 5904        'name',
 5905        'password',
 5906        'secret_store_id',
 5907        'subdomain',
 5908        'tags',
 5909        'url',
 5910        'username',
 5911    ]
 5912
 5913    def __init__(
 5914        self,
 5915        bind_interface=None,
 5916        default_path=None,
 5917        egress_filter=None,
 5918        headers_blacklist=None,
 5919        healthcheck_path=None,
 5920        healthy=None,
 5921        host_override=None,
 5922        id=None,
 5923        name=None,
 5924        password=None,
 5925        secret_store_id=None,
 5926        subdomain=None,
 5927        tags=None,
 5928        url=None,
 5929        username=None,
 5930    ):
 5931        self.bind_interface = bind_interface if bind_interface is not None else ''
 5932        '''
 5933         Bind interface
 5934        '''
 5935        self.default_path = default_path if default_path is not None else ''
 5936        self.egress_filter = egress_filter if egress_filter is not None else ''
 5937        '''
 5938         A filter applied to the routing logic to pin datasource to nodes.
 5939        '''
 5940        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5941        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5942        self.healthy = healthy if healthy is not None else False
 5943        '''
 5944         True if the datasource is reachable and the credentials are valid.
 5945        '''
 5946        self.host_override = host_override if host_override is not None else ''
 5947        self.id = id if id is not None else ''
 5948        '''
 5949         Unique identifier of the Resource.
 5950        '''
 5951        self.name = name if name is not None else ''
 5952        '''
 5953         Unique human-readable name of the Resource.
 5954        '''
 5955        self.password = password if password is not None else ''
 5956        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5957        '''
 5958         ID of the secret store containing credentials for this resource, if any.
 5959        '''
 5960        self.subdomain = subdomain if subdomain is not None else ''
 5961        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5962        '''
 5963         Tags is a map of key, value pairs.
 5964        '''
 5965        self.url = url if url is not None else ''
 5966        self.username = username if username is not None else ''
 5967
 5968    def __repr__(self):
 5969        return '<sdm.HTTPBasicAuth ' + \
 5970            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5971            'default_path: ' + repr(self.default_path) + ' ' +\
 5972            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5973            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5974            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5975            'healthy: ' + repr(self.healthy) + ' ' +\
 5976            'host_override: ' + repr(self.host_override) + ' ' +\
 5977            'id: ' + repr(self.id) + ' ' +\
 5978            'name: ' + repr(self.name) + ' ' +\
 5979            'password: ' + repr(self.password) + ' ' +\
 5980            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5981            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5982            'tags: ' + repr(self.tags) + ' ' +\
 5983            'url: ' + repr(self.url) + ' ' +\
 5984            'username: ' + repr(self.username) + ' ' +\
 5985            '>'
 5986
 5987    def to_dict(self):
 5988        return {
 5989            'bind_interface': self.bind_interface,
 5990            'default_path': self.default_path,
 5991            'egress_filter': self.egress_filter,
 5992            'headers_blacklist': self.headers_blacklist,
 5993            'healthcheck_path': self.healthcheck_path,
 5994            'healthy': self.healthy,
 5995            'host_override': self.host_override,
 5996            'id': self.id,
 5997            'name': self.name,
 5998            'password': self.password,
 5999            'secret_store_id': self.secret_store_id,
 6000            'subdomain': self.subdomain,
 6001            'tags': self.tags,
 6002            'url': self.url,
 6003            'username': self.username,
 6004        }
 6005
 6006    @classmethod
 6007    def from_dict(cls, d):
 6008        return cls(
 6009            bind_interface=d.get('bind_interface'),
 6010            default_path=d.get('default_path'),
 6011            egress_filter=d.get('egress_filter'),
 6012            headers_blacklist=d.get('headers_blacklist'),
 6013            healthcheck_path=d.get('healthcheck_path'),
 6014            healthy=d.get('healthy'),
 6015            host_override=d.get('host_override'),
 6016            id=d.get('id'),
 6017            name=d.get('name'),
 6018            password=d.get('password'),
 6019            secret_store_id=d.get('secret_store_id'),
 6020            subdomain=d.get('subdomain'),
 6021            tags=d.get('tags'),
 6022            url=d.get('url'),
 6023            username=d.get('username'),
 6024        )
 6025
 6026
 6027class HTTPNoAuth:
 6028    __slots__ = [
 6029        'bind_interface',
 6030        'default_path',
 6031        'egress_filter',
 6032        'headers_blacklist',
 6033        'healthcheck_path',
 6034        'healthy',
 6035        'host_override',
 6036        'id',
 6037        'name',
 6038        'secret_store_id',
 6039        'subdomain',
 6040        'tags',
 6041        'url',
 6042    ]
 6043
 6044    def __init__(
 6045        self,
 6046        bind_interface=None,
 6047        default_path=None,
 6048        egress_filter=None,
 6049        headers_blacklist=None,
 6050        healthcheck_path=None,
 6051        healthy=None,
 6052        host_override=None,
 6053        id=None,
 6054        name=None,
 6055        secret_store_id=None,
 6056        subdomain=None,
 6057        tags=None,
 6058        url=None,
 6059    ):
 6060        self.bind_interface = bind_interface if bind_interface is not None else ''
 6061        '''
 6062         Bind interface
 6063        '''
 6064        self.default_path = default_path if default_path is not None else ''
 6065        self.egress_filter = egress_filter if egress_filter is not None else ''
 6066        '''
 6067         A filter applied to the routing logic to pin datasource to nodes.
 6068        '''
 6069        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6070        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6071        self.healthy = healthy if healthy is not None else False
 6072        '''
 6073         True if the datasource is reachable and the credentials are valid.
 6074        '''
 6075        self.host_override = host_override if host_override is not None else ''
 6076        self.id = id if id is not None else ''
 6077        '''
 6078         Unique identifier of the Resource.
 6079        '''
 6080        self.name = name if name is not None else ''
 6081        '''
 6082         Unique human-readable name of the Resource.
 6083        '''
 6084        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6085        '''
 6086         ID of the secret store containing credentials for this resource, if any.
 6087        '''
 6088        self.subdomain = subdomain if subdomain is not None else ''
 6089        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6090        '''
 6091         Tags is a map of key, value pairs.
 6092        '''
 6093        self.url = url if url is not None else ''
 6094
 6095    def __repr__(self):
 6096        return '<sdm.HTTPNoAuth ' + \
 6097            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6098            'default_path: ' + repr(self.default_path) + ' ' +\
 6099            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6100            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6101            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6102            'healthy: ' + repr(self.healthy) + ' ' +\
 6103            'host_override: ' + repr(self.host_override) + ' ' +\
 6104            'id: ' + repr(self.id) + ' ' +\
 6105            'name: ' + repr(self.name) + ' ' +\
 6106            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6107            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6108            'tags: ' + repr(self.tags) + ' ' +\
 6109            'url: ' + repr(self.url) + ' ' +\
 6110            '>'
 6111
 6112    def to_dict(self):
 6113        return {
 6114            'bind_interface': self.bind_interface,
 6115            'default_path': self.default_path,
 6116            'egress_filter': self.egress_filter,
 6117            'headers_blacklist': self.headers_blacklist,
 6118            'healthcheck_path': self.healthcheck_path,
 6119            'healthy': self.healthy,
 6120            'host_override': self.host_override,
 6121            'id': self.id,
 6122            'name': self.name,
 6123            'secret_store_id': self.secret_store_id,
 6124            'subdomain': self.subdomain,
 6125            'tags': self.tags,
 6126            'url': self.url,
 6127        }
 6128
 6129    @classmethod
 6130    def from_dict(cls, d):
 6131        return cls(
 6132            bind_interface=d.get('bind_interface'),
 6133            default_path=d.get('default_path'),
 6134            egress_filter=d.get('egress_filter'),
 6135            headers_blacklist=d.get('headers_blacklist'),
 6136            healthcheck_path=d.get('healthcheck_path'),
 6137            healthy=d.get('healthy'),
 6138            host_override=d.get('host_override'),
 6139            id=d.get('id'),
 6140            name=d.get('name'),
 6141            secret_store_id=d.get('secret_store_id'),
 6142            subdomain=d.get('subdomain'),
 6143            tags=d.get('tags'),
 6144            url=d.get('url'),
 6145        )
 6146
 6147
 6148class Kubernetes:
 6149    __slots__ = [
 6150        'bind_interface',
 6151        'certificate_authority',
 6152        'client_certificate',
 6153        'client_key',
 6154        'egress_filter',
 6155        'healthcheck_namespace',
 6156        'healthy',
 6157        'hostname',
 6158        'id',
 6159        'name',
 6160        'port',
 6161        'port_override',
 6162        'remote_identity_group_id',
 6163        'remote_identity_healthcheck_username',
 6164        'secret_store_id',
 6165        'tags',
 6166    ]
 6167
 6168    def __init__(
 6169        self,
 6170        bind_interface=None,
 6171        certificate_authority=None,
 6172        client_certificate=None,
 6173        client_key=None,
 6174        egress_filter=None,
 6175        healthcheck_namespace=None,
 6176        healthy=None,
 6177        hostname=None,
 6178        id=None,
 6179        name=None,
 6180        port=None,
 6181        port_override=None,
 6182        remote_identity_group_id=None,
 6183        remote_identity_healthcheck_username=None,
 6184        secret_store_id=None,
 6185        tags=None,
 6186    ):
 6187        self.bind_interface = bind_interface if bind_interface is not None else ''
 6188        '''
 6189         Bind interface
 6190        '''
 6191        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6192        self.client_certificate = client_certificate if client_certificate is not None else ''
 6193        self.client_key = client_key if client_key is not None else ''
 6194        self.egress_filter = egress_filter if egress_filter is not None else ''
 6195        '''
 6196         A filter applied to the routing logic to pin datasource to nodes.
 6197        '''
 6198        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6199        '''
 6200         The path used to check the health of your connection.  Defaults to `default`.
 6201        '''
 6202        self.healthy = healthy if healthy is not None else False
 6203        '''
 6204         True if the datasource is reachable and the credentials are valid.
 6205        '''
 6206        self.hostname = hostname if hostname is not None else ''
 6207        self.id = id if id is not None else ''
 6208        '''
 6209         Unique identifier of the Resource.
 6210        '''
 6211        self.name = name if name is not None else ''
 6212        '''
 6213         Unique human-readable name of the Resource.
 6214        '''
 6215        self.port = port if port is not None else 0
 6216        self.port_override = port_override if port_override is not None else 0
 6217        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6218        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6219        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6220        '''
 6221         ID of the secret store containing credentials for this resource, if any.
 6222        '''
 6223        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6224        '''
 6225         Tags is a map of key, value pairs.
 6226        '''
 6227
 6228    def __repr__(self):
 6229        return '<sdm.Kubernetes ' + \
 6230            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6231            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6232            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6233            'client_key: ' + repr(self.client_key) + ' ' +\
 6234            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6235            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6236            'healthy: ' + repr(self.healthy) + ' ' +\
 6237            'hostname: ' + repr(self.hostname) + ' ' +\
 6238            'id: ' + repr(self.id) + ' ' +\
 6239            'name: ' + repr(self.name) + ' ' +\
 6240            'port: ' + repr(self.port) + ' ' +\
 6241            'port_override: ' + repr(self.port_override) + ' ' +\
 6242            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6243            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6244            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6245            'tags: ' + repr(self.tags) + ' ' +\
 6246            '>'
 6247
 6248    def to_dict(self):
 6249        return {
 6250            'bind_interface': self.bind_interface,
 6251            'certificate_authority': self.certificate_authority,
 6252            'client_certificate': self.client_certificate,
 6253            'client_key': self.client_key,
 6254            'egress_filter': self.egress_filter,
 6255            'healthcheck_namespace': self.healthcheck_namespace,
 6256            'healthy': self.healthy,
 6257            'hostname': self.hostname,
 6258            'id': self.id,
 6259            'name': self.name,
 6260            'port': self.port,
 6261            'port_override': self.port_override,
 6262            'remote_identity_group_id': self.remote_identity_group_id,
 6263            'remote_identity_healthcheck_username':
 6264            self.remote_identity_healthcheck_username,
 6265            'secret_store_id': self.secret_store_id,
 6266            'tags': self.tags,
 6267        }
 6268
 6269    @classmethod
 6270    def from_dict(cls, d):
 6271        return cls(
 6272            bind_interface=d.get('bind_interface'),
 6273            certificate_authority=d.get('certificate_authority'),
 6274            client_certificate=d.get('client_certificate'),
 6275            client_key=d.get('client_key'),
 6276            egress_filter=d.get('egress_filter'),
 6277            healthcheck_namespace=d.get('healthcheck_namespace'),
 6278            healthy=d.get('healthy'),
 6279            hostname=d.get('hostname'),
 6280            id=d.get('id'),
 6281            name=d.get('name'),
 6282            port=d.get('port'),
 6283            port_override=d.get('port_override'),
 6284            remote_identity_group_id=d.get('remote_identity_group_id'),
 6285            remote_identity_healthcheck_username=d.get(
 6286                'remote_identity_healthcheck_username'),
 6287            secret_store_id=d.get('secret_store_id'),
 6288            tags=d.get('tags'),
 6289        )
 6290
 6291
 6292class KubernetesBasicAuth:
 6293    __slots__ = [
 6294        'bind_interface',
 6295        'egress_filter',
 6296        'healthcheck_namespace',
 6297        'healthy',
 6298        'hostname',
 6299        'id',
 6300        'name',
 6301        'password',
 6302        'port',
 6303        'port_override',
 6304        'secret_store_id',
 6305        'tags',
 6306        'username',
 6307    ]
 6308
 6309    def __init__(
 6310        self,
 6311        bind_interface=None,
 6312        egress_filter=None,
 6313        healthcheck_namespace=None,
 6314        healthy=None,
 6315        hostname=None,
 6316        id=None,
 6317        name=None,
 6318        password=None,
 6319        port=None,
 6320        port_override=None,
 6321        secret_store_id=None,
 6322        tags=None,
 6323        username=None,
 6324    ):
 6325        self.bind_interface = bind_interface if bind_interface is not None else ''
 6326        '''
 6327         Bind interface
 6328        '''
 6329        self.egress_filter = egress_filter if egress_filter is not None else ''
 6330        '''
 6331         A filter applied to the routing logic to pin datasource to nodes.
 6332        '''
 6333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6334        '''
 6335         The path used to check the health of your connection.  Defaults to `default`.
 6336        '''
 6337        self.healthy = healthy if healthy is not None else False
 6338        '''
 6339         True if the datasource is reachable and the credentials are valid.
 6340        '''
 6341        self.hostname = hostname if hostname is not None else ''
 6342        self.id = id if id is not None else ''
 6343        '''
 6344         Unique identifier of the Resource.
 6345        '''
 6346        self.name = name if name is not None else ''
 6347        '''
 6348         Unique human-readable name of the Resource.
 6349        '''
 6350        self.password = password if password is not None else ''
 6351        self.port = port if port is not None else 0
 6352        self.port_override = port_override if port_override is not None else 0
 6353        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6354        '''
 6355         ID of the secret store containing credentials for this resource, if any.
 6356        '''
 6357        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6358        '''
 6359         Tags is a map of key, value pairs.
 6360        '''
 6361        self.username = username if username is not None else ''
 6362
 6363    def __repr__(self):
 6364        return '<sdm.KubernetesBasicAuth ' + \
 6365            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6366            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6367            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6368            'healthy: ' + repr(self.healthy) + ' ' +\
 6369            'hostname: ' + repr(self.hostname) + ' ' +\
 6370            'id: ' + repr(self.id) + ' ' +\
 6371            'name: ' + repr(self.name) + ' ' +\
 6372            'password: ' + repr(self.password) + ' ' +\
 6373            'port: ' + repr(self.port) + ' ' +\
 6374            'port_override: ' + repr(self.port_override) + ' ' +\
 6375            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6376            'tags: ' + repr(self.tags) + ' ' +\
 6377            'username: ' + repr(self.username) + ' ' +\
 6378            '>'
 6379
 6380    def to_dict(self):
 6381        return {
 6382            'bind_interface': self.bind_interface,
 6383            'egress_filter': self.egress_filter,
 6384            'healthcheck_namespace': self.healthcheck_namespace,
 6385            'healthy': self.healthy,
 6386            'hostname': self.hostname,
 6387            'id': self.id,
 6388            'name': self.name,
 6389            'password': self.password,
 6390            'port': self.port,
 6391            'port_override': self.port_override,
 6392            'secret_store_id': self.secret_store_id,
 6393            'tags': self.tags,
 6394            'username': self.username,
 6395        }
 6396
 6397    @classmethod
 6398    def from_dict(cls, d):
 6399        return cls(
 6400            bind_interface=d.get('bind_interface'),
 6401            egress_filter=d.get('egress_filter'),
 6402            healthcheck_namespace=d.get('healthcheck_namespace'),
 6403            healthy=d.get('healthy'),
 6404            hostname=d.get('hostname'),
 6405            id=d.get('id'),
 6406            name=d.get('name'),
 6407            password=d.get('password'),
 6408            port=d.get('port'),
 6409            port_override=d.get('port_override'),
 6410            secret_store_id=d.get('secret_store_id'),
 6411            tags=d.get('tags'),
 6412            username=d.get('username'),
 6413        )
 6414
 6415
 6416class KubernetesServiceAccount:
 6417    __slots__ = [
 6418        'bind_interface',
 6419        'egress_filter',
 6420        'healthcheck_namespace',
 6421        'healthy',
 6422        'hostname',
 6423        'id',
 6424        'name',
 6425        'port',
 6426        'port_override',
 6427        'remote_identity_group_id',
 6428        'remote_identity_healthcheck_username',
 6429        'secret_store_id',
 6430        'tags',
 6431        'token',
 6432    ]
 6433
 6434    def __init__(
 6435        self,
 6436        bind_interface=None,
 6437        egress_filter=None,
 6438        healthcheck_namespace=None,
 6439        healthy=None,
 6440        hostname=None,
 6441        id=None,
 6442        name=None,
 6443        port=None,
 6444        port_override=None,
 6445        remote_identity_group_id=None,
 6446        remote_identity_healthcheck_username=None,
 6447        secret_store_id=None,
 6448        tags=None,
 6449        token=None,
 6450    ):
 6451        self.bind_interface = bind_interface if bind_interface is not None else ''
 6452        '''
 6453         Bind interface
 6454        '''
 6455        self.egress_filter = egress_filter if egress_filter is not None else ''
 6456        '''
 6457         A filter applied to the routing logic to pin datasource to nodes.
 6458        '''
 6459        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6460        '''
 6461         The path used to check the health of your connection.  Defaults to `default`.
 6462        '''
 6463        self.healthy = healthy if healthy is not None else False
 6464        '''
 6465         True if the datasource is reachable and the credentials are valid.
 6466        '''
 6467        self.hostname = hostname if hostname is not None else ''
 6468        self.id = id if id is not None else ''
 6469        '''
 6470         Unique identifier of the Resource.
 6471        '''
 6472        self.name = name if name is not None else ''
 6473        '''
 6474         Unique human-readable name of the Resource.
 6475        '''
 6476        self.port = port if port is not None else 0
 6477        self.port_override = port_override if port_override is not None else 0
 6478        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6479        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6481        '''
 6482         ID of the secret store containing credentials for this resource, if any.
 6483        '''
 6484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6485        '''
 6486         Tags is a map of key, value pairs.
 6487        '''
 6488        self.token = token if token is not None else ''
 6489
 6490    def __repr__(self):
 6491        return '<sdm.KubernetesServiceAccount ' + \
 6492            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6493            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6494            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6495            'healthy: ' + repr(self.healthy) + ' ' +\
 6496            'hostname: ' + repr(self.hostname) + ' ' +\
 6497            'id: ' + repr(self.id) + ' ' +\
 6498            'name: ' + repr(self.name) + ' ' +\
 6499            'port: ' + repr(self.port) + ' ' +\
 6500            'port_override: ' + repr(self.port_override) + ' ' +\
 6501            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6502            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6503            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6504            'tags: ' + repr(self.tags) + ' ' +\
 6505            'token: ' + repr(self.token) + ' ' +\
 6506            '>'
 6507
 6508    def to_dict(self):
 6509        return {
 6510            'bind_interface': self.bind_interface,
 6511            'egress_filter': self.egress_filter,
 6512            'healthcheck_namespace': self.healthcheck_namespace,
 6513            'healthy': self.healthy,
 6514            'hostname': self.hostname,
 6515            'id': self.id,
 6516            'name': self.name,
 6517            'port': self.port,
 6518            'port_override': self.port_override,
 6519            'remote_identity_group_id': self.remote_identity_group_id,
 6520            'remote_identity_healthcheck_username':
 6521            self.remote_identity_healthcheck_username,
 6522            'secret_store_id': self.secret_store_id,
 6523            'tags': self.tags,
 6524            'token': self.token,
 6525        }
 6526
 6527    @classmethod
 6528    def from_dict(cls, d):
 6529        return cls(
 6530            bind_interface=d.get('bind_interface'),
 6531            egress_filter=d.get('egress_filter'),
 6532            healthcheck_namespace=d.get('healthcheck_namespace'),
 6533            healthy=d.get('healthy'),
 6534            hostname=d.get('hostname'),
 6535            id=d.get('id'),
 6536            name=d.get('name'),
 6537            port=d.get('port'),
 6538            port_override=d.get('port_override'),
 6539            remote_identity_group_id=d.get('remote_identity_group_id'),
 6540            remote_identity_healthcheck_username=d.get(
 6541                'remote_identity_healthcheck_username'),
 6542            secret_store_id=d.get('secret_store_id'),
 6543            tags=d.get('tags'),
 6544            token=d.get('token'),
 6545        )
 6546
 6547
 6548class KubernetesServiceAccountUserImpersonation:
 6549    __slots__ = [
 6550        'bind_interface',
 6551        'egress_filter',
 6552        'healthcheck_namespace',
 6553        'healthy',
 6554        'hostname',
 6555        'id',
 6556        'name',
 6557        'port',
 6558        'port_override',
 6559        'secret_store_id',
 6560        'tags',
 6561        'token',
 6562    ]
 6563
 6564    def __init__(
 6565        self,
 6566        bind_interface=None,
 6567        egress_filter=None,
 6568        healthcheck_namespace=None,
 6569        healthy=None,
 6570        hostname=None,
 6571        id=None,
 6572        name=None,
 6573        port=None,
 6574        port_override=None,
 6575        secret_store_id=None,
 6576        tags=None,
 6577        token=None,
 6578    ):
 6579        self.bind_interface = bind_interface if bind_interface is not None else ''
 6580        '''
 6581         Bind interface
 6582        '''
 6583        self.egress_filter = egress_filter if egress_filter is not None else ''
 6584        '''
 6585         A filter applied to the routing logic to pin datasource to nodes.
 6586        '''
 6587        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6588        '''
 6589         The path used to check the health of your connection.  Defaults to `default`.
 6590        '''
 6591        self.healthy = healthy if healthy is not None else False
 6592        '''
 6593         True if the datasource is reachable and the credentials are valid.
 6594        '''
 6595        self.hostname = hostname if hostname is not None else ''
 6596        self.id = id if id is not None else ''
 6597        '''
 6598         Unique identifier of the Resource.
 6599        '''
 6600        self.name = name if name is not None else ''
 6601        '''
 6602         Unique human-readable name of the Resource.
 6603        '''
 6604        self.port = port if port is not None else 0
 6605        self.port_override = port_override if port_override is not None else 0
 6606        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6607        '''
 6608         ID of the secret store containing credentials for this resource, if any.
 6609        '''
 6610        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6611        '''
 6612         Tags is a map of key, value pairs.
 6613        '''
 6614        self.token = token if token is not None else ''
 6615
 6616    def __repr__(self):
 6617        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6618            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6619            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6620            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6621            'healthy: ' + repr(self.healthy) + ' ' +\
 6622            'hostname: ' + repr(self.hostname) + ' ' +\
 6623            'id: ' + repr(self.id) + ' ' +\
 6624            'name: ' + repr(self.name) + ' ' +\
 6625            'port: ' + repr(self.port) + ' ' +\
 6626            'port_override: ' + repr(self.port_override) + ' ' +\
 6627            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6628            'tags: ' + repr(self.tags) + ' ' +\
 6629            'token: ' + repr(self.token) + ' ' +\
 6630            '>'
 6631
 6632    def to_dict(self):
 6633        return {
 6634            'bind_interface': self.bind_interface,
 6635            'egress_filter': self.egress_filter,
 6636            'healthcheck_namespace': self.healthcheck_namespace,
 6637            'healthy': self.healthy,
 6638            'hostname': self.hostname,
 6639            'id': self.id,
 6640            'name': self.name,
 6641            'port': self.port,
 6642            'port_override': self.port_override,
 6643            'secret_store_id': self.secret_store_id,
 6644            'tags': self.tags,
 6645            'token': self.token,
 6646        }
 6647
 6648    @classmethod
 6649    def from_dict(cls, d):
 6650        return cls(
 6651            bind_interface=d.get('bind_interface'),
 6652            egress_filter=d.get('egress_filter'),
 6653            healthcheck_namespace=d.get('healthcheck_namespace'),
 6654            healthy=d.get('healthy'),
 6655            hostname=d.get('hostname'),
 6656            id=d.get('id'),
 6657            name=d.get('name'),
 6658            port=d.get('port'),
 6659            port_override=d.get('port_override'),
 6660            secret_store_id=d.get('secret_store_id'),
 6661            tags=d.get('tags'),
 6662            token=d.get('token'),
 6663        )
 6664
 6665
 6666class KubernetesUserImpersonation:
 6667    __slots__ = [
 6668        'bind_interface',
 6669        'certificate_authority',
 6670        'client_certificate',
 6671        'client_key',
 6672        'egress_filter',
 6673        'healthcheck_namespace',
 6674        'healthy',
 6675        'hostname',
 6676        'id',
 6677        'name',
 6678        'port',
 6679        'port_override',
 6680        'secret_store_id',
 6681        'tags',
 6682    ]
 6683
 6684    def __init__(
 6685        self,
 6686        bind_interface=None,
 6687        certificate_authority=None,
 6688        client_certificate=None,
 6689        client_key=None,
 6690        egress_filter=None,
 6691        healthcheck_namespace=None,
 6692        healthy=None,
 6693        hostname=None,
 6694        id=None,
 6695        name=None,
 6696        port=None,
 6697        port_override=None,
 6698        secret_store_id=None,
 6699        tags=None,
 6700    ):
 6701        self.bind_interface = bind_interface if bind_interface is not None else ''
 6702        '''
 6703         Bind interface
 6704        '''
 6705        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6706        self.client_certificate = client_certificate if client_certificate is not None else ''
 6707        self.client_key = client_key if client_key is not None else ''
 6708        self.egress_filter = egress_filter if egress_filter is not None else ''
 6709        '''
 6710         A filter applied to the routing logic to pin datasource to nodes.
 6711        '''
 6712        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6713        '''
 6714         The path used to check the health of your connection.  Defaults to `default`.
 6715        '''
 6716        self.healthy = healthy if healthy is not None else False
 6717        '''
 6718         True if the datasource is reachable and the credentials are valid.
 6719        '''
 6720        self.hostname = hostname if hostname is not None else ''
 6721        self.id = id if id is not None else ''
 6722        '''
 6723         Unique identifier of the Resource.
 6724        '''
 6725        self.name = name if name is not None else ''
 6726        '''
 6727         Unique human-readable name of the Resource.
 6728        '''
 6729        self.port = port if port is not None else 0
 6730        self.port_override = port_override if port_override is not None else 0
 6731        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6732        '''
 6733         ID of the secret store containing credentials for this resource, if any.
 6734        '''
 6735        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6736        '''
 6737         Tags is a map of key, value pairs.
 6738        '''
 6739
 6740    def __repr__(self):
 6741        return '<sdm.KubernetesUserImpersonation ' + \
 6742            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6743            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6744            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6745            'client_key: ' + repr(self.client_key) + ' ' +\
 6746            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6747            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6748            'healthy: ' + repr(self.healthy) + ' ' +\
 6749            'hostname: ' + repr(self.hostname) + ' ' +\
 6750            'id: ' + repr(self.id) + ' ' +\
 6751            'name: ' + repr(self.name) + ' ' +\
 6752            'port: ' + repr(self.port) + ' ' +\
 6753            'port_override: ' + repr(self.port_override) + ' ' +\
 6754            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6755            'tags: ' + repr(self.tags) + ' ' +\
 6756            '>'
 6757
 6758    def to_dict(self):
 6759        return {
 6760            'bind_interface': self.bind_interface,
 6761            'certificate_authority': self.certificate_authority,
 6762            'client_certificate': self.client_certificate,
 6763            'client_key': self.client_key,
 6764            'egress_filter': self.egress_filter,
 6765            'healthcheck_namespace': self.healthcheck_namespace,
 6766            'healthy': self.healthy,
 6767            'hostname': self.hostname,
 6768            'id': self.id,
 6769            'name': self.name,
 6770            'port': self.port,
 6771            'port_override': self.port_override,
 6772            'secret_store_id': self.secret_store_id,
 6773            'tags': self.tags,
 6774        }
 6775
 6776    @classmethod
 6777    def from_dict(cls, d):
 6778        return cls(
 6779            bind_interface=d.get('bind_interface'),
 6780            certificate_authority=d.get('certificate_authority'),
 6781            client_certificate=d.get('client_certificate'),
 6782            client_key=d.get('client_key'),
 6783            egress_filter=d.get('egress_filter'),
 6784            healthcheck_namespace=d.get('healthcheck_namespace'),
 6785            healthy=d.get('healthy'),
 6786            hostname=d.get('hostname'),
 6787            id=d.get('id'),
 6788            name=d.get('name'),
 6789            port=d.get('port'),
 6790            port_override=d.get('port_override'),
 6791            secret_store_id=d.get('secret_store_id'),
 6792            tags=d.get('tags'),
 6793        )
 6794
 6795
 6796class MTLSMysql:
 6797    '''
 6798    MTLSMysql is currently unstable, and its API may change, or it may be removed,
 6799    without a major version bump.
 6800    '''
 6801    __slots__ = [
 6802        'bind_interface',
 6803        'certificate_authority',
 6804        'client_certificate',
 6805        'client_key',
 6806        'database',
 6807        'egress_filter',
 6808        'healthy',
 6809        'hostname',
 6810        'id',
 6811        'name',
 6812        'password',
 6813        'port',
 6814        'port_override',
 6815        'secret_store_id',
 6816        'server_name',
 6817        'tags',
 6818        'username',
 6819    ]
 6820
 6821    def __init__(
 6822        self,
 6823        bind_interface=None,
 6824        certificate_authority=None,
 6825        client_certificate=None,
 6826        client_key=None,
 6827        database=None,
 6828        egress_filter=None,
 6829        healthy=None,
 6830        hostname=None,
 6831        id=None,
 6832        name=None,
 6833        password=None,
 6834        port=None,
 6835        port_override=None,
 6836        secret_store_id=None,
 6837        server_name=None,
 6838        tags=None,
 6839        username=None,
 6840    ):
 6841        self.bind_interface = bind_interface if bind_interface is not None else ''
 6842        '''
 6843         Bind interface
 6844        '''
 6845        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6846        self.client_certificate = client_certificate if client_certificate is not None else ''
 6847        self.client_key = client_key if client_key is not None else ''
 6848        self.database = database if database is not None else ''
 6849        self.egress_filter = egress_filter if egress_filter is not None else ''
 6850        '''
 6851         A filter applied to the routing logic to pin datasource to nodes.
 6852        '''
 6853        self.healthy = healthy if healthy is not None else False
 6854        '''
 6855         True if the datasource is reachable and the credentials are valid.
 6856        '''
 6857        self.hostname = hostname if hostname is not None else ''
 6858        self.id = id if id is not None else ''
 6859        '''
 6860         Unique identifier of the Resource.
 6861        '''
 6862        self.name = name if name is not None else ''
 6863        '''
 6864         Unique human-readable name of the Resource.
 6865        '''
 6866        self.password = password if password is not None else ''
 6867        self.port = port if port is not None else 0
 6868        self.port_override = port_override if port_override is not None else 0
 6869        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6870        '''
 6871         ID of the secret store containing credentials for this resource, if any.
 6872        '''
 6873        self.server_name = server_name if server_name is not None else ''
 6874        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6875        '''
 6876         Tags is a map of key, value pairs.
 6877        '''
 6878        self.username = username if username is not None else ''
 6879
 6880    def __repr__(self):
 6881        return '<sdm.MTLSMysql ' + \
 6882            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6883            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6884            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6885            'client_key: ' + repr(self.client_key) + ' ' +\
 6886            'database: ' + repr(self.database) + ' ' +\
 6887            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6888            'healthy: ' + repr(self.healthy) + ' ' +\
 6889            'hostname: ' + repr(self.hostname) + ' ' +\
 6890            'id: ' + repr(self.id) + ' ' +\
 6891            'name: ' + repr(self.name) + ' ' +\
 6892            'password: ' + repr(self.password) + ' ' +\
 6893            'port: ' + repr(self.port) + ' ' +\
 6894            'port_override: ' + repr(self.port_override) + ' ' +\
 6895            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6896            'server_name: ' + repr(self.server_name) + ' ' +\
 6897            'tags: ' + repr(self.tags) + ' ' +\
 6898            'username: ' + repr(self.username) + ' ' +\
 6899            '>'
 6900
 6901    def to_dict(self):
 6902        return {
 6903            'bind_interface': self.bind_interface,
 6904            'certificate_authority': self.certificate_authority,
 6905            'client_certificate': self.client_certificate,
 6906            'client_key': self.client_key,
 6907            'database': self.database,
 6908            'egress_filter': self.egress_filter,
 6909            'healthy': self.healthy,
 6910            'hostname': self.hostname,
 6911            'id': self.id,
 6912            'name': self.name,
 6913            'password': self.password,
 6914            'port': self.port,
 6915            'port_override': self.port_override,
 6916            'secret_store_id': self.secret_store_id,
 6917            'server_name': self.server_name,
 6918            'tags': self.tags,
 6919            'username': self.username,
 6920        }
 6921
 6922    @classmethod
 6923    def from_dict(cls, d):
 6924        return cls(
 6925            bind_interface=d.get('bind_interface'),
 6926            certificate_authority=d.get('certificate_authority'),
 6927            client_certificate=d.get('client_certificate'),
 6928            client_key=d.get('client_key'),
 6929            database=d.get('database'),
 6930            egress_filter=d.get('egress_filter'),
 6931            healthy=d.get('healthy'),
 6932            hostname=d.get('hostname'),
 6933            id=d.get('id'),
 6934            name=d.get('name'),
 6935            password=d.get('password'),
 6936            port=d.get('port'),
 6937            port_override=d.get('port_override'),
 6938            secret_store_id=d.get('secret_store_id'),
 6939            server_name=d.get('server_name'),
 6940            tags=d.get('tags'),
 6941            username=d.get('username'),
 6942        )
 6943
 6944
 6945class MTLSPostgres:
 6946    __slots__ = [
 6947        'bind_interface',
 6948        'certificate_authority',
 6949        'client_certificate',
 6950        'client_key',
 6951        'database',
 6952        'egress_filter',
 6953        'healthy',
 6954        'hostname',
 6955        'id',
 6956        'name',
 6957        'override_database',
 6958        'password',
 6959        'port',
 6960        'port_override',
 6961        'secret_store_id',
 6962        'server_name',
 6963        'tags',
 6964        'username',
 6965    ]
 6966
 6967    def __init__(
 6968        self,
 6969        bind_interface=None,
 6970        certificate_authority=None,
 6971        client_certificate=None,
 6972        client_key=None,
 6973        database=None,
 6974        egress_filter=None,
 6975        healthy=None,
 6976        hostname=None,
 6977        id=None,
 6978        name=None,
 6979        override_database=None,
 6980        password=None,
 6981        port=None,
 6982        port_override=None,
 6983        secret_store_id=None,
 6984        server_name=None,
 6985        tags=None,
 6986        username=None,
 6987    ):
 6988        self.bind_interface = bind_interface if bind_interface is not None else ''
 6989        '''
 6990         Bind interface
 6991        '''
 6992        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6993        self.client_certificate = client_certificate if client_certificate is not None else ''
 6994        self.client_key = client_key if client_key is not None else ''
 6995        self.database = database if database is not None else ''
 6996        self.egress_filter = egress_filter if egress_filter is not None else ''
 6997        '''
 6998         A filter applied to the routing logic to pin datasource to nodes.
 6999        '''
 7000        self.healthy = healthy if healthy is not None else False
 7001        '''
 7002         True if the datasource is reachable and the credentials are valid.
 7003        '''
 7004        self.hostname = hostname if hostname is not None else ''
 7005        self.id = id if id is not None else ''
 7006        '''
 7007         Unique identifier of the Resource.
 7008        '''
 7009        self.name = name if name is not None else ''
 7010        '''
 7011         Unique human-readable name of the Resource.
 7012        '''
 7013        self.override_database = override_database if override_database is not None else False
 7014        self.password = password if password is not None else ''
 7015        self.port = port if port is not None else 0
 7016        self.port_override = port_override if port_override is not None else 0
 7017        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7018        '''
 7019         ID of the secret store containing credentials for this resource, if any.
 7020        '''
 7021        self.server_name = server_name if server_name is not None else ''
 7022        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7023        '''
 7024         Tags is a map of key, value pairs.
 7025        '''
 7026        self.username = username if username is not None else ''
 7027
 7028    def __repr__(self):
 7029        return '<sdm.MTLSPostgres ' + \
 7030            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7031            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7032            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7033            'client_key: ' + repr(self.client_key) + ' ' +\
 7034            'database: ' + repr(self.database) + ' ' +\
 7035            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7036            'healthy: ' + repr(self.healthy) + ' ' +\
 7037            'hostname: ' + repr(self.hostname) + ' ' +\
 7038            'id: ' + repr(self.id) + ' ' +\
 7039            'name: ' + repr(self.name) + ' ' +\
 7040            'override_database: ' + repr(self.override_database) + ' ' +\
 7041            'password: ' + repr(self.password) + ' ' +\
 7042            'port: ' + repr(self.port) + ' ' +\
 7043            'port_override: ' + repr(self.port_override) + ' ' +\
 7044            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7045            'server_name: ' + repr(self.server_name) + ' ' +\
 7046            'tags: ' + repr(self.tags) + ' ' +\
 7047            'username: ' + repr(self.username) + ' ' +\
 7048            '>'
 7049
 7050    def to_dict(self):
 7051        return {
 7052            'bind_interface': self.bind_interface,
 7053            'certificate_authority': self.certificate_authority,
 7054            'client_certificate': self.client_certificate,
 7055            'client_key': self.client_key,
 7056            'database': self.database,
 7057            'egress_filter': self.egress_filter,
 7058            'healthy': self.healthy,
 7059            'hostname': self.hostname,
 7060            'id': self.id,
 7061            'name': self.name,
 7062            'override_database': self.override_database,
 7063            'password': self.password,
 7064            'port': self.port,
 7065            'port_override': self.port_override,
 7066            'secret_store_id': self.secret_store_id,
 7067            'server_name': self.server_name,
 7068            'tags': self.tags,
 7069            'username': self.username,
 7070        }
 7071
 7072    @classmethod
 7073    def from_dict(cls, d):
 7074        return cls(
 7075            bind_interface=d.get('bind_interface'),
 7076            certificate_authority=d.get('certificate_authority'),
 7077            client_certificate=d.get('client_certificate'),
 7078            client_key=d.get('client_key'),
 7079            database=d.get('database'),
 7080            egress_filter=d.get('egress_filter'),
 7081            healthy=d.get('healthy'),
 7082            hostname=d.get('hostname'),
 7083            id=d.get('id'),
 7084            name=d.get('name'),
 7085            override_database=d.get('override_database'),
 7086            password=d.get('password'),
 7087            port=d.get('port'),
 7088            port_override=d.get('port_override'),
 7089            secret_store_id=d.get('secret_store_id'),
 7090            server_name=d.get('server_name'),
 7091            tags=d.get('tags'),
 7092            username=d.get('username'),
 7093        )
 7094
 7095
 7096class Maria:
 7097    __slots__ = [
 7098        'bind_interface',
 7099        'database',
 7100        'egress_filter',
 7101        'healthy',
 7102        'hostname',
 7103        'id',
 7104        'name',
 7105        'password',
 7106        'port',
 7107        'port_override',
 7108        'secret_store_id',
 7109        'tags',
 7110        'username',
 7111    ]
 7112
 7113    def __init__(
 7114        self,
 7115        bind_interface=None,
 7116        database=None,
 7117        egress_filter=None,
 7118        healthy=None,
 7119        hostname=None,
 7120        id=None,
 7121        name=None,
 7122        password=None,
 7123        port=None,
 7124        port_override=None,
 7125        secret_store_id=None,
 7126        tags=None,
 7127        username=None,
 7128    ):
 7129        self.bind_interface = bind_interface if bind_interface is not None else ''
 7130        '''
 7131         Bind interface
 7132        '''
 7133        self.database = database if database is not None else ''
 7134        self.egress_filter = egress_filter if egress_filter is not None else ''
 7135        '''
 7136         A filter applied to the routing logic to pin datasource to nodes.
 7137        '''
 7138        self.healthy = healthy if healthy is not None else False
 7139        '''
 7140         True if the datasource is reachable and the credentials are valid.
 7141        '''
 7142        self.hostname = hostname if hostname is not None else ''
 7143        self.id = id if id is not None else ''
 7144        '''
 7145         Unique identifier of the Resource.
 7146        '''
 7147        self.name = name if name is not None else ''
 7148        '''
 7149         Unique human-readable name of the Resource.
 7150        '''
 7151        self.password = password if password is not None else ''
 7152        self.port = port if port is not None else 0
 7153        self.port_override = port_override if port_override is not None else 0
 7154        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7155        '''
 7156         ID of the secret store containing credentials for this resource, if any.
 7157        '''
 7158        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7159        '''
 7160         Tags is a map of key, value pairs.
 7161        '''
 7162        self.username = username if username is not None else ''
 7163
 7164    def __repr__(self):
 7165        return '<sdm.Maria ' + \
 7166            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7167            'database: ' + repr(self.database) + ' ' +\
 7168            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7169            'healthy: ' + repr(self.healthy) + ' ' +\
 7170            'hostname: ' + repr(self.hostname) + ' ' +\
 7171            'id: ' + repr(self.id) + ' ' +\
 7172            'name: ' + repr(self.name) + ' ' +\
 7173            'password: ' + repr(self.password) + ' ' +\
 7174            'port: ' + repr(self.port) + ' ' +\
 7175            'port_override: ' + repr(self.port_override) + ' ' +\
 7176            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7177            'tags: ' + repr(self.tags) + ' ' +\
 7178            'username: ' + repr(self.username) + ' ' +\
 7179            '>'
 7180
 7181    def to_dict(self):
 7182        return {
 7183            'bind_interface': self.bind_interface,
 7184            'database': self.database,
 7185            'egress_filter': self.egress_filter,
 7186            'healthy': self.healthy,
 7187            'hostname': self.hostname,
 7188            'id': self.id,
 7189            'name': self.name,
 7190            'password': self.password,
 7191            'port': self.port,
 7192            'port_override': self.port_override,
 7193            'secret_store_id': self.secret_store_id,
 7194            'tags': self.tags,
 7195            'username': self.username,
 7196        }
 7197
 7198    @classmethod
 7199    def from_dict(cls, d):
 7200        return cls(
 7201            bind_interface=d.get('bind_interface'),
 7202            database=d.get('database'),
 7203            egress_filter=d.get('egress_filter'),
 7204            healthy=d.get('healthy'),
 7205            hostname=d.get('hostname'),
 7206            id=d.get('id'),
 7207            name=d.get('name'),
 7208            password=d.get('password'),
 7209            port=d.get('port'),
 7210            port_override=d.get('port_override'),
 7211            secret_store_id=d.get('secret_store_id'),
 7212            tags=d.get('tags'),
 7213            username=d.get('username'),
 7214        )
 7215
 7216
 7217class Memcached:
 7218    __slots__ = [
 7219        'bind_interface',
 7220        'egress_filter',
 7221        'healthy',
 7222        'hostname',
 7223        'id',
 7224        'name',
 7225        'port',
 7226        'port_override',
 7227        'secret_store_id',
 7228        'tags',
 7229    ]
 7230
 7231    def __init__(
 7232        self,
 7233        bind_interface=None,
 7234        egress_filter=None,
 7235        healthy=None,
 7236        hostname=None,
 7237        id=None,
 7238        name=None,
 7239        port=None,
 7240        port_override=None,
 7241        secret_store_id=None,
 7242        tags=None,
 7243    ):
 7244        self.bind_interface = bind_interface if bind_interface is not None else ''
 7245        '''
 7246         Bind interface
 7247        '''
 7248        self.egress_filter = egress_filter if egress_filter is not None else ''
 7249        '''
 7250         A filter applied to the routing logic to pin datasource to nodes.
 7251        '''
 7252        self.healthy = healthy if healthy is not None else False
 7253        '''
 7254         True if the datasource is reachable and the credentials are valid.
 7255        '''
 7256        self.hostname = hostname if hostname is not None else ''
 7257        self.id = id if id is not None else ''
 7258        '''
 7259         Unique identifier of the Resource.
 7260        '''
 7261        self.name = name if name is not None else ''
 7262        '''
 7263         Unique human-readable name of the Resource.
 7264        '''
 7265        self.port = port if port is not None else 0
 7266        self.port_override = port_override if port_override is not None else 0
 7267        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7268        '''
 7269         ID of the secret store containing credentials for this resource, if any.
 7270        '''
 7271        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7272        '''
 7273         Tags is a map of key, value pairs.
 7274        '''
 7275
 7276    def __repr__(self):
 7277        return '<sdm.Memcached ' + \
 7278            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7279            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7280            'healthy: ' + repr(self.healthy) + ' ' +\
 7281            'hostname: ' + repr(self.hostname) + ' ' +\
 7282            'id: ' + repr(self.id) + ' ' +\
 7283            'name: ' + repr(self.name) + ' ' +\
 7284            'port: ' + repr(self.port) + ' ' +\
 7285            'port_override: ' + repr(self.port_override) + ' ' +\
 7286            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7287            'tags: ' + repr(self.tags) + ' ' +\
 7288            '>'
 7289
 7290    def to_dict(self):
 7291        return {
 7292            'bind_interface': self.bind_interface,
 7293            'egress_filter': self.egress_filter,
 7294            'healthy': self.healthy,
 7295            'hostname': self.hostname,
 7296            'id': self.id,
 7297            'name': self.name,
 7298            'port': self.port,
 7299            'port_override': self.port_override,
 7300            'secret_store_id': self.secret_store_id,
 7301            'tags': self.tags,
 7302        }
 7303
 7304    @classmethod
 7305    def from_dict(cls, d):
 7306        return cls(
 7307            bind_interface=d.get('bind_interface'),
 7308            egress_filter=d.get('egress_filter'),
 7309            healthy=d.get('healthy'),
 7310            hostname=d.get('hostname'),
 7311            id=d.get('id'),
 7312            name=d.get('name'),
 7313            port=d.get('port'),
 7314            port_override=d.get('port_override'),
 7315            secret_store_id=d.get('secret_store_id'),
 7316            tags=d.get('tags'),
 7317        )
 7318
 7319
 7320class Memsql:
 7321    __slots__ = [
 7322        'bind_interface',
 7323        'database',
 7324        'egress_filter',
 7325        'healthy',
 7326        'hostname',
 7327        'id',
 7328        'name',
 7329        'password',
 7330        'port',
 7331        'port_override',
 7332        'secret_store_id',
 7333        'tags',
 7334        'username',
 7335    ]
 7336
 7337    def __init__(
 7338        self,
 7339        bind_interface=None,
 7340        database=None,
 7341        egress_filter=None,
 7342        healthy=None,
 7343        hostname=None,
 7344        id=None,
 7345        name=None,
 7346        password=None,
 7347        port=None,
 7348        port_override=None,
 7349        secret_store_id=None,
 7350        tags=None,
 7351        username=None,
 7352    ):
 7353        self.bind_interface = bind_interface if bind_interface is not None else ''
 7354        '''
 7355         Bind interface
 7356        '''
 7357        self.database = database if database is not None else ''
 7358        self.egress_filter = egress_filter if egress_filter is not None else ''
 7359        '''
 7360         A filter applied to the routing logic to pin datasource to nodes.
 7361        '''
 7362        self.healthy = healthy if healthy is not None else False
 7363        '''
 7364         True if the datasource is reachable and the credentials are valid.
 7365        '''
 7366        self.hostname = hostname if hostname is not None else ''
 7367        self.id = id if id is not None else ''
 7368        '''
 7369         Unique identifier of the Resource.
 7370        '''
 7371        self.name = name if name is not None else ''
 7372        '''
 7373         Unique human-readable name of the Resource.
 7374        '''
 7375        self.password = password if password is not None else ''
 7376        self.port = port if port is not None else 0
 7377        self.port_override = port_override if port_override is not None else 0
 7378        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7379        '''
 7380         ID of the secret store containing credentials for this resource, if any.
 7381        '''
 7382        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7383        '''
 7384         Tags is a map of key, value pairs.
 7385        '''
 7386        self.username = username if username is not None else ''
 7387
 7388    def __repr__(self):
 7389        return '<sdm.Memsql ' + \
 7390            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7391            'database: ' + repr(self.database) + ' ' +\
 7392            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7393            'healthy: ' + repr(self.healthy) + ' ' +\
 7394            'hostname: ' + repr(self.hostname) + ' ' +\
 7395            'id: ' + repr(self.id) + ' ' +\
 7396            'name: ' + repr(self.name) + ' ' +\
 7397            'password: ' + repr(self.password) + ' ' +\
 7398            'port: ' + repr(self.port) + ' ' +\
 7399            'port_override: ' + repr(self.port_override) + ' ' +\
 7400            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7401            'tags: ' + repr(self.tags) + ' ' +\
 7402            'username: ' + repr(self.username) + ' ' +\
 7403            '>'
 7404
 7405    def to_dict(self):
 7406        return {
 7407            'bind_interface': self.bind_interface,
 7408            'database': self.database,
 7409            'egress_filter': self.egress_filter,
 7410            'healthy': self.healthy,
 7411            'hostname': self.hostname,
 7412            'id': self.id,
 7413            'name': self.name,
 7414            'password': self.password,
 7415            'port': self.port,
 7416            'port_override': self.port_override,
 7417            'secret_store_id': self.secret_store_id,
 7418            'tags': self.tags,
 7419            'username': self.username,
 7420        }
 7421
 7422    @classmethod
 7423    def from_dict(cls, d):
 7424        return cls(
 7425            bind_interface=d.get('bind_interface'),
 7426            database=d.get('database'),
 7427            egress_filter=d.get('egress_filter'),
 7428            healthy=d.get('healthy'),
 7429            hostname=d.get('hostname'),
 7430            id=d.get('id'),
 7431            name=d.get('name'),
 7432            password=d.get('password'),
 7433            port=d.get('port'),
 7434            port_override=d.get('port_override'),
 7435            secret_store_id=d.get('secret_store_id'),
 7436            tags=d.get('tags'),
 7437            username=d.get('username'),
 7438        )
 7439
 7440
 7441class MongoHost:
 7442    '''
 7443    MongoHost is currently unstable, and its API may change, or it may be removed,
 7444    without a major version bump.
 7445    '''
 7446    __slots__ = [
 7447        'auth_database',
 7448        'bind_interface',
 7449        'egress_filter',
 7450        'healthy',
 7451        'hostname',
 7452        'id',
 7453        'name',
 7454        'password',
 7455        'port',
 7456        'port_override',
 7457        'secret_store_id',
 7458        'tags',
 7459        'tls_required',
 7460        'username',
 7461    ]
 7462
 7463    def __init__(
 7464        self,
 7465        auth_database=None,
 7466        bind_interface=None,
 7467        egress_filter=None,
 7468        healthy=None,
 7469        hostname=None,
 7470        id=None,
 7471        name=None,
 7472        password=None,
 7473        port=None,
 7474        port_override=None,
 7475        secret_store_id=None,
 7476        tags=None,
 7477        tls_required=None,
 7478        username=None,
 7479    ):
 7480        self.auth_database = auth_database if auth_database is not None else ''
 7481        self.bind_interface = bind_interface if bind_interface is not None else ''
 7482        '''
 7483         Bind interface
 7484        '''
 7485        self.egress_filter = egress_filter if egress_filter is not None else ''
 7486        '''
 7487         A filter applied to the routing logic to pin datasource to nodes.
 7488        '''
 7489        self.healthy = healthy if healthy is not None else False
 7490        '''
 7491         True if the datasource is reachable and the credentials are valid.
 7492        '''
 7493        self.hostname = hostname if hostname is not None else ''
 7494        self.id = id if id is not None else ''
 7495        '''
 7496         Unique identifier of the Resource.
 7497        '''
 7498        self.name = name if name is not None else ''
 7499        '''
 7500         Unique human-readable name of the Resource.
 7501        '''
 7502        self.password = password if password is not None else ''
 7503        self.port = port if port is not None else 0
 7504        self.port_override = port_override if port_override is not None else 0
 7505        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7506        '''
 7507         ID of the secret store containing credentials for this resource, if any.
 7508        '''
 7509        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7510        '''
 7511         Tags is a map of key, value pairs.
 7512        '''
 7513        self.tls_required = tls_required if tls_required is not None else False
 7514        self.username = username if username is not None else ''
 7515
 7516    def __repr__(self):
 7517        return '<sdm.MongoHost ' + \
 7518            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7519            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7520            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7521            'healthy: ' + repr(self.healthy) + ' ' +\
 7522            'hostname: ' + repr(self.hostname) + ' ' +\
 7523            'id: ' + repr(self.id) + ' ' +\
 7524            'name: ' + repr(self.name) + ' ' +\
 7525            'password: ' + repr(self.password) + ' ' +\
 7526            'port: ' + repr(self.port) + ' ' +\
 7527            'port_override: ' + repr(self.port_override) + ' ' +\
 7528            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7529            'tags: ' + repr(self.tags) + ' ' +\
 7530            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7531            'username: ' + repr(self.username) + ' ' +\
 7532            '>'
 7533
 7534    def to_dict(self):
 7535        return {
 7536            'auth_database': self.auth_database,
 7537            'bind_interface': self.bind_interface,
 7538            'egress_filter': self.egress_filter,
 7539            'healthy': self.healthy,
 7540            'hostname': self.hostname,
 7541            'id': self.id,
 7542            'name': self.name,
 7543            'password': self.password,
 7544            'port': self.port,
 7545            'port_override': self.port_override,
 7546            'secret_store_id': self.secret_store_id,
 7547            'tags': self.tags,
 7548            'tls_required': self.tls_required,
 7549            'username': self.username,
 7550        }
 7551
 7552    @classmethod
 7553    def from_dict(cls, d):
 7554        return cls(
 7555            auth_database=d.get('auth_database'),
 7556            bind_interface=d.get('bind_interface'),
 7557            egress_filter=d.get('egress_filter'),
 7558            healthy=d.get('healthy'),
 7559            hostname=d.get('hostname'),
 7560            id=d.get('id'),
 7561            name=d.get('name'),
 7562            password=d.get('password'),
 7563            port=d.get('port'),
 7564            port_override=d.get('port_override'),
 7565            secret_store_id=d.get('secret_store_id'),
 7566            tags=d.get('tags'),
 7567            tls_required=d.get('tls_required'),
 7568            username=d.get('username'),
 7569        )
 7570
 7571
 7572class MongoLegacyHost:
 7573    __slots__ = [
 7574        'auth_database',
 7575        'bind_interface',
 7576        'egress_filter',
 7577        'healthy',
 7578        'hostname',
 7579        'id',
 7580        'name',
 7581        'password',
 7582        'port',
 7583        'port_override',
 7584        'replica_set',
 7585        'secret_store_id',
 7586        'tags',
 7587        'tls_required',
 7588        'username',
 7589    ]
 7590
 7591    def __init__(
 7592        self,
 7593        auth_database=None,
 7594        bind_interface=None,
 7595        egress_filter=None,
 7596        healthy=None,
 7597        hostname=None,
 7598        id=None,
 7599        name=None,
 7600        password=None,
 7601        port=None,
 7602        port_override=None,
 7603        replica_set=None,
 7604        secret_store_id=None,
 7605        tags=None,
 7606        tls_required=None,
 7607        username=None,
 7608    ):
 7609        self.auth_database = auth_database if auth_database is not None else ''
 7610        self.bind_interface = bind_interface if bind_interface is not None else ''
 7611        '''
 7612         Bind interface
 7613        '''
 7614        self.egress_filter = egress_filter if egress_filter is not None else ''
 7615        '''
 7616         A filter applied to the routing logic to pin datasource to nodes.
 7617        '''
 7618        self.healthy = healthy if healthy is not None else False
 7619        '''
 7620         True if the datasource is reachable and the credentials are valid.
 7621        '''
 7622        self.hostname = hostname if hostname is not None else ''
 7623        self.id = id if id is not None else ''
 7624        '''
 7625         Unique identifier of the Resource.
 7626        '''
 7627        self.name = name if name is not None else ''
 7628        '''
 7629         Unique human-readable name of the Resource.
 7630        '''
 7631        self.password = password if password is not None else ''
 7632        self.port = port if port is not None else 0
 7633        self.port_override = port_override if port_override is not None else 0
 7634        self.replica_set = replica_set if replica_set is not None else ''
 7635        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7636        '''
 7637         ID of the secret store containing credentials for this resource, if any.
 7638        '''
 7639        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7640        '''
 7641         Tags is a map of key, value pairs.
 7642        '''
 7643        self.tls_required = tls_required if tls_required is not None else False
 7644        self.username = username if username is not None else ''
 7645
 7646    def __repr__(self):
 7647        return '<sdm.MongoLegacyHost ' + \
 7648            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7649            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7650            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7651            'healthy: ' + repr(self.healthy) + ' ' +\
 7652            'hostname: ' + repr(self.hostname) + ' ' +\
 7653            'id: ' + repr(self.id) + ' ' +\
 7654            'name: ' + repr(self.name) + ' ' +\
 7655            'password: ' + repr(self.password) + ' ' +\
 7656            'port: ' + repr(self.port) + ' ' +\
 7657            'port_override: ' + repr(self.port_override) + ' ' +\
 7658            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7659            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7660            'tags: ' + repr(self.tags) + ' ' +\
 7661            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7662            'username: ' + repr(self.username) + ' ' +\
 7663            '>'
 7664
 7665    def to_dict(self):
 7666        return {
 7667            'auth_database': self.auth_database,
 7668            'bind_interface': self.bind_interface,
 7669            'egress_filter': self.egress_filter,
 7670            'healthy': self.healthy,
 7671            'hostname': self.hostname,
 7672            'id': self.id,
 7673            'name': self.name,
 7674            'password': self.password,
 7675            'port': self.port,
 7676            'port_override': self.port_override,
 7677            'replica_set': self.replica_set,
 7678            'secret_store_id': self.secret_store_id,
 7679            'tags': self.tags,
 7680            'tls_required': self.tls_required,
 7681            'username': self.username,
 7682        }
 7683
 7684    @classmethod
 7685    def from_dict(cls, d):
 7686        return cls(
 7687            auth_database=d.get('auth_database'),
 7688            bind_interface=d.get('bind_interface'),
 7689            egress_filter=d.get('egress_filter'),
 7690            healthy=d.get('healthy'),
 7691            hostname=d.get('hostname'),
 7692            id=d.get('id'),
 7693            name=d.get('name'),
 7694            password=d.get('password'),
 7695            port=d.get('port'),
 7696            port_override=d.get('port_override'),
 7697            replica_set=d.get('replica_set'),
 7698            secret_store_id=d.get('secret_store_id'),
 7699            tags=d.get('tags'),
 7700            tls_required=d.get('tls_required'),
 7701            username=d.get('username'),
 7702        )
 7703
 7704
 7705class MongoLegacyReplicaset:
 7706    __slots__ = [
 7707        'auth_database',
 7708        'bind_interface',
 7709        'connect_to_replica',
 7710        'egress_filter',
 7711        'healthy',
 7712        'hostname',
 7713        'id',
 7714        'name',
 7715        'password',
 7716        'port',
 7717        'port_override',
 7718        'replica_set',
 7719        'secret_store_id',
 7720        'tags',
 7721        'tls_required',
 7722        'username',
 7723    ]
 7724
 7725    def __init__(
 7726        self,
 7727        auth_database=None,
 7728        bind_interface=None,
 7729        connect_to_replica=None,
 7730        egress_filter=None,
 7731        healthy=None,
 7732        hostname=None,
 7733        id=None,
 7734        name=None,
 7735        password=None,
 7736        port=None,
 7737        port_override=None,
 7738        replica_set=None,
 7739        secret_store_id=None,
 7740        tags=None,
 7741        tls_required=None,
 7742        username=None,
 7743    ):
 7744        self.auth_database = auth_database if auth_database is not None else ''
 7745        self.bind_interface = bind_interface if bind_interface is not None else ''
 7746        '''
 7747         Bind interface
 7748        '''
 7749        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7750        self.egress_filter = egress_filter if egress_filter is not None else ''
 7751        '''
 7752         A filter applied to the routing logic to pin datasource to nodes.
 7753        '''
 7754        self.healthy = healthy if healthy is not None else False
 7755        '''
 7756         True if the datasource is reachable and the credentials are valid.
 7757        '''
 7758        self.hostname = hostname if hostname is not None else ''
 7759        self.id = id if id is not None else ''
 7760        '''
 7761         Unique identifier of the Resource.
 7762        '''
 7763        self.name = name if name is not None else ''
 7764        '''
 7765         Unique human-readable name of the Resource.
 7766        '''
 7767        self.password = password if password is not None else ''
 7768        self.port = port if port is not None else 0
 7769        self.port_override = port_override if port_override is not None else 0
 7770        self.replica_set = replica_set if replica_set is not None else ''
 7771        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7772        '''
 7773         ID of the secret store containing credentials for this resource, if any.
 7774        '''
 7775        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7776        '''
 7777         Tags is a map of key, value pairs.
 7778        '''
 7779        self.tls_required = tls_required if tls_required is not None else False
 7780        self.username = username if username is not None else ''
 7781
 7782    def __repr__(self):
 7783        return '<sdm.MongoLegacyReplicaset ' + \
 7784            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7785            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7786            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7787            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7788            'healthy: ' + repr(self.healthy) + ' ' +\
 7789            'hostname: ' + repr(self.hostname) + ' ' +\
 7790            'id: ' + repr(self.id) + ' ' +\
 7791            'name: ' + repr(self.name) + ' ' +\
 7792            'password: ' + repr(self.password) + ' ' +\
 7793            'port: ' + repr(self.port) + ' ' +\
 7794            'port_override: ' + repr(self.port_override) + ' ' +\
 7795            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7796            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7797            'tags: ' + repr(self.tags) + ' ' +\
 7798            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7799            'username: ' + repr(self.username) + ' ' +\
 7800            '>'
 7801
 7802    def to_dict(self):
 7803        return {
 7804            'auth_database': self.auth_database,
 7805            'bind_interface': self.bind_interface,
 7806            'connect_to_replica': self.connect_to_replica,
 7807            'egress_filter': self.egress_filter,
 7808            'healthy': self.healthy,
 7809            'hostname': self.hostname,
 7810            'id': self.id,
 7811            'name': self.name,
 7812            'password': self.password,
 7813            'port': self.port,
 7814            'port_override': self.port_override,
 7815            'replica_set': self.replica_set,
 7816            'secret_store_id': self.secret_store_id,
 7817            'tags': self.tags,
 7818            'tls_required': self.tls_required,
 7819            'username': self.username,
 7820        }
 7821
 7822    @classmethod
 7823    def from_dict(cls, d):
 7824        return cls(
 7825            auth_database=d.get('auth_database'),
 7826            bind_interface=d.get('bind_interface'),
 7827            connect_to_replica=d.get('connect_to_replica'),
 7828            egress_filter=d.get('egress_filter'),
 7829            healthy=d.get('healthy'),
 7830            hostname=d.get('hostname'),
 7831            id=d.get('id'),
 7832            name=d.get('name'),
 7833            password=d.get('password'),
 7834            port=d.get('port'),
 7835            port_override=d.get('port_override'),
 7836            replica_set=d.get('replica_set'),
 7837            secret_store_id=d.get('secret_store_id'),
 7838            tags=d.get('tags'),
 7839            tls_required=d.get('tls_required'),
 7840            username=d.get('username'),
 7841        )
 7842
 7843
 7844class MongoReplicaSet:
 7845    '''
 7846    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
 7847    without a major version bump.
 7848    '''
 7849    __slots__ = [
 7850        'auth_database',
 7851        'bind_interface',
 7852        'connect_to_replica',
 7853        'egress_filter',
 7854        'healthy',
 7855        'hostname',
 7856        'id',
 7857        'name',
 7858        'password',
 7859        'port',
 7860        'port_override',
 7861        'replica_set',
 7862        'secret_store_id',
 7863        'tags',
 7864        'tls_required',
 7865        'username',
 7866    ]
 7867
 7868    def __init__(
 7869        self,
 7870        auth_database=None,
 7871        bind_interface=None,
 7872        connect_to_replica=None,
 7873        egress_filter=None,
 7874        healthy=None,
 7875        hostname=None,
 7876        id=None,
 7877        name=None,
 7878        password=None,
 7879        port=None,
 7880        port_override=None,
 7881        replica_set=None,
 7882        secret_store_id=None,
 7883        tags=None,
 7884        tls_required=None,
 7885        username=None,
 7886    ):
 7887        self.auth_database = auth_database if auth_database is not None else ''
 7888        self.bind_interface = bind_interface if bind_interface is not None else ''
 7889        '''
 7890         Bind interface
 7891        '''
 7892        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 7893        self.egress_filter = egress_filter if egress_filter is not None else ''
 7894        '''
 7895         A filter applied to the routing logic to pin datasource to nodes.
 7896        '''
 7897        self.healthy = healthy if healthy is not None else False
 7898        '''
 7899         True if the datasource is reachable and the credentials are valid.
 7900        '''
 7901        self.hostname = hostname if hostname is not None else ''
 7902        self.id = id if id is not None else ''
 7903        '''
 7904         Unique identifier of the Resource.
 7905        '''
 7906        self.name = name if name is not None else ''
 7907        '''
 7908         Unique human-readable name of the Resource.
 7909        '''
 7910        self.password = password if password is not None else ''
 7911        self.port = port if port is not None else 0
 7912        self.port_override = port_override if port_override is not None else 0
 7913        self.replica_set = replica_set if replica_set is not None else ''
 7914        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7915        '''
 7916         ID of the secret store containing credentials for this resource, if any.
 7917        '''
 7918        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7919        '''
 7920         Tags is a map of key, value pairs.
 7921        '''
 7922        self.tls_required = tls_required if tls_required is not None else False
 7923        self.username = username if username is not None else ''
 7924
 7925    def __repr__(self):
 7926        return '<sdm.MongoReplicaSet ' + \
 7927            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7928            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7929            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 7930            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7931            'healthy: ' + repr(self.healthy) + ' ' +\
 7932            'hostname: ' + repr(self.hostname) + ' ' +\
 7933            'id: ' + repr(self.id) + ' ' +\
 7934            'name: ' + repr(self.name) + ' ' +\
 7935            'password: ' + repr(self.password) + ' ' +\
 7936            'port: ' + repr(self.port) + ' ' +\
 7937            'port_override: ' + repr(self.port_override) + ' ' +\
 7938            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7939            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7940            'tags: ' + repr(self.tags) + ' ' +\
 7941            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7942            'username: ' + repr(self.username) + ' ' +\
 7943            '>'
 7944
 7945    def to_dict(self):
 7946        return {
 7947            'auth_database': self.auth_database,
 7948            'bind_interface': self.bind_interface,
 7949            'connect_to_replica': self.connect_to_replica,
 7950            'egress_filter': self.egress_filter,
 7951            'healthy': self.healthy,
 7952            'hostname': self.hostname,
 7953            'id': self.id,
 7954            'name': self.name,
 7955            'password': self.password,
 7956            'port': self.port,
 7957            'port_override': self.port_override,
 7958            'replica_set': self.replica_set,
 7959            'secret_store_id': self.secret_store_id,
 7960            'tags': self.tags,
 7961            'tls_required': self.tls_required,
 7962            'username': self.username,
 7963        }
 7964
 7965    @classmethod
 7966    def from_dict(cls, d):
 7967        return cls(
 7968            auth_database=d.get('auth_database'),
 7969            bind_interface=d.get('bind_interface'),
 7970            connect_to_replica=d.get('connect_to_replica'),
 7971            egress_filter=d.get('egress_filter'),
 7972            healthy=d.get('healthy'),
 7973            hostname=d.get('hostname'),
 7974            id=d.get('id'),
 7975            name=d.get('name'),
 7976            password=d.get('password'),
 7977            port=d.get('port'),
 7978            port_override=d.get('port_override'),
 7979            replica_set=d.get('replica_set'),
 7980            secret_store_id=d.get('secret_store_id'),
 7981            tags=d.get('tags'),
 7982            tls_required=d.get('tls_required'),
 7983            username=d.get('username'),
 7984        )
 7985
 7986
 7987class MongoShardedCluster:
 7988    '''
 7989    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
 7990    without a major version bump.
 7991    '''
 7992    __slots__ = [
 7993        'auth_database',
 7994        'bind_interface',
 7995        'egress_filter',
 7996        'healthy',
 7997        'hostname',
 7998        'id',
 7999        'name',
 8000        'password',
 8001        'port_override',
 8002        'secret_store_id',
 8003        'tags',
 8004        'tls_required',
 8005        'username',
 8006    ]
 8007
 8008    def __init__(
 8009        self,
 8010        auth_database=None,
 8011        bind_interface=None,
 8012        egress_filter=None,
 8013        healthy=None,
 8014        hostname=None,
 8015        id=None,
 8016        name=None,
 8017        password=None,
 8018        port_override=None,
 8019        secret_store_id=None,
 8020        tags=None,
 8021        tls_required=None,
 8022        username=None,
 8023    ):
 8024        self.auth_database = auth_database if auth_database is not None else ''
 8025        self.bind_interface = bind_interface if bind_interface is not None else ''
 8026        '''
 8027         Bind interface
 8028        '''
 8029        self.egress_filter = egress_filter if egress_filter is not None else ''
 8030        '''
 8031         A filter applied to the routing logic to pin datasource to nodes.
 8032        '''
 8033        self.healthy = healthy if healthy is not None else False
 8034        '''
 8035         True if the datasource is reachable and the credentials are valid.
 8036        '''
 8037        self.hostname = hostname if hostname is not None else ''
 8038        self.id = id if id is not None else ''
 8039        '''
 8040         Unique identifier of the Resource.
 8041        '''
 8042        self.name = name if name is not None else ''
 8043        '''
 8044         Unique human-readable name of the Resource.
 8045        '''
 8046        self.password = password if password is not None else ''
 8047        self.port_override = port_override if port_override is not None else 0
 8048        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8049        '''
 8050         ID of the secret store containing credentials for this resource, if any.
 8051        '''
 8052        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8053        '''
 8054         Tags is a map of key, value pairs.
 8055        '''
 8056        self.tls_required = tls_required if tls_required is not None else False
 8057        self.username = username if username is not None else ''
 8058
 8059    def __repr__(self):
 8060        return '<sdm.MongoShardedCluster ' + \
 8061            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8062            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8063            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8064            'healthy: ' + repr(self.healthy) + ' ' +\
 8065            'hostname: ' + repr(self.hostname) + ' ' +\
 8066            'id: ' + repr(self.id) + ' ' +\
 8067            'name: ' + repr(self.name) + ' ' +\
 8068            'password: ' + repr(self.password) + ' ' +\
 8069            'port_override: ' + repr(self.port_override) + ' ' +\
 8070            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8071            'tags: ' + repr(self.tags) + ' ' +\
 8072            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8073            'username: ' + repr(self.username) + ' ' +\
 8074            '>'
 8075
 8076    def to_dict(self):
 8077        return {
 8078            'auth_database': self.auth_database,
 8079            'bind_interface': self.bind_interface,
 8080            'egress_filter': self.egress_filter,
 8081            'healthy': self.healthy,
 8082            'hostname': self.hostname,
 8083            'id': self.id,
 8084            'name': self.name,
 8085            'password': self.password,
 8086            'port_override': self.port_override,
 8087            'secret_store_id': self.secret_store_id,
 8088            'tags': self.tags,
 8089            'tls_required': self.tls_required,
 8090            'username': self.username,
 8091        }
 8092
 8093    @classmethod
 8094    def from_dict(cls, d):
 8095        return cls(
 8096            auth_database=d.get('auth_database'),
 8097            bind_interface=d.get('bind_interface'),
 8098            egress_filter=d.get('egress_filter'),
 8099            healthy=d.get('healthy'),
 8100            hostname=d.get('hostname'),
 8101            id=d.get('id'),
 8102            name=d.get('name'),
 8103            password=d.get('password'),
 8104            port_override=d.get('port_override'),
 8105            secret_store_id=d.get('secret_store_id'),
 8106            tags=d.get('tags'),
 8107            tls_required=d.get('tls_required'),
 8108            username=d.get('username'),
 8109        )
 8110
 8111
 8112class Mysql:
 8113    __slots__ = [
 8114        'bind_interface',
 8115        'database',
 8116        'egress_filter',
 8117        'healthy',
 8118        'hostname',
 8119        'id',
 8120        'name',
 8121        'password',
 8122        'port',
 8123        'port_override',
 8124        'secret_store_id',
 8125        'tags',
 8126        'username',
 8127    ]
 8128
 8129    def __init__(
 8130        self,
 8131        bind_interface=None,
 8132        database=None,
 8133        egress_filter=None,
 8134        healthy=None,
 8135        hostname=None,
 8136        id=None,
 8137        name=None,
 8138        password=None,
 8139        port=None,
 8140        port_override=None,
 8141        secret_store_id=None,
 8142        tags=None,
 8143        username=None,
 8144    ):
 8145        self.bind_interface = bind_interface if bind_interface is not None else ''
 8146        '''
 8147         Bind interface
 8148        '''
 8149        self.database = database if database is not None else ''
 8150        self.egress_filter = egress_filter if egress_filter is not None else ''
 8151        '''
 8152         A filter applied to the routing logic to pin datasource to nodes.
 8153        '''
 8154        self.healthy = healthy if healthy is not None else False
 8155        '''
 8156         True if the datasource is reachable and the credentials are valid.
 8157        '''
 8158        self.hostname = hostname if hostname is not None else ''
 8159        self.id = id if id is not None else ''
 8160        '''
 8161         Unique identifier of the Resource.
 8162        '''
 8163        self.name = name if name is not None else ''
 8164        '''
 8165         Unique human-readable name of the Resource.
 8166        '''
 8167        self.password = password if password is not None else ''
 8168        self.port = port if port is not None else 0
 8169        self.port_override = port_override if port_override is not None else 0
 8170        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8171        '''
 8172         ID of the secret store containing credentials for this resource, if any.
 8173        '''
 8174        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8175        '''
 8176         Tags is a map of key, value pairs.
 8177        '''
 8178        self.username = username if username is not None else ''
 8179
 8180    def __repr__(self):
 8181        return '<sdm.Mysql ' + \
 8182            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8183            'database: ' + repr(self.database) + ' ' +\
 8184            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8185            'healthy: ' + repr(self.healthy) + ' ' +\
 8186            'hostname: ' + repr(self.hostname) + ' ' +\
 8187            'id: ' + repr(self.id) + ' ' +\
 8188            'name: ' + repr(self.name) + ' ' +\
 8189            'password: ' + repr(self.password) + ' ' +\
 8190            'port: ' + repr(self.port) + ' ' +\
 8191            'port_override: ' + repr(self.port_override) + ' ' +\
 8192            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8193            'tags: ' + repr(self.tags) + ' ' +\
 8194            'username: ' + repr(self.username) + ' ' +\
 8195            '>'
 8196
 8197    def to_dict(self):
 8198        return {
 8199            'bind_interface': self.bind_interface,
 8200            'database': self.database,
 8201            'egress_filter': self.egress_filter,
 8202            'healthy': self.healthy,
 8203            'hostname': self.hostname,
 8204            'id': self.id,
 8205            'name': self.name,
 8206            'password': self.password,
 8207            'port': self.port,
 8208            'port_override': self.port_override,
 8209            'secret_store_id': self.secret_store_id,
 8210            'tags': self.tags,
 8211            'username': self.username,
 8212        }
 8213
 8214    @classmethod
 8215    def from_dict(cls, d):
 8216        return cls(
 8217            bind_interface=d.get('bind_interface'),
 8218            database=d.get('database'),
 8219            egress_filter=d.get('egress_filter'),
 8220            healthy=d.get('healthy'),
 8221            hostname=d.get('hostname'),
 8222            id=d.get('id'),
 8223            name=d.get('name'),
 8224            password=d.get('password'),
 8225            port=d.get('port'),
 8226            port_override=d.get('port_override'),
 8227            secret_store_id=d.get('secret_store_id'),
 8228            tags=d.get('tags'),
 8229            username=d.get('username'),
 8230        )
 8231
 8232
 8233class Neptune:
 8234    __slots__ = [
 8235        'bind_interface',
 8236        'egress_filter',
 8237        'endpoint',
 8238        'healthy',
 8239        'id',
 8240        'name',
 8241        'port',
 8242        'port_override',
 8243        'secret_store_id',
 8244        'tags',
 8245    ]
 8246
 8247    def __init__(
 8248        self,
 8249        bind_interface=None,
 8250        egress_filter=None,
 8251        endpoint=None,
 8252        healthy=None,
 8253        id=None,
 8254        name=None,
 8255        port=None,
 8256        port_override=None,
 8257        secret_store_id=None,
 8258        tags=None,
 8259    ):
 8260        self.bind_interface = bind_interface if bind_interface is not None else ''
 8261        '''
 8262         Bind interface
 8263        '''
 8264        self.egress_filter = egress_filter if egress_filter is not None else ''
 8265        '''
 8266         A filter applied to the routing logic to pin datasource to nodes.
 8267        '''
 8268        self.endpoint = endpoint if endpoint is not None else ''
 8269        self.healthy = healthy if healthy is not None else False
 8270        '''
 8271         True if the datasource is reachable and the credentials are valid.
 8272        '''
 8273        self.id = id if id is not None else ''
 8274        '''
 8275         Unique identifier of the Resource.
 8276        '''
 8277        self.name = name if name is not None else ''
 8278        '''
 8279         Unique human-readable name of the Resource.
 8280        '''
 8281        self.port = port if port is not None else 0
 8282        self.port_override = port_override if port_override is not None else 0
 8283        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8284        '''
 8285         ID of the secret store containing credentials for this resource, if any.
 8286        '''
 8287        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8288        '''
 8289         Tags is a map of key, value pairs.
 8290        '''
 8291
 8292    def __repr__(self):
 8293        return '<sdm.Neptune ' + \
 8294            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8295            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8296            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8297            'healthy: ' + repr(self.healthy) + ' ' +\
 8298            'id: ' + repr(self.id) + ' ' +\
 8299            'name: ' + repr(self.name) + ' ' +\
 8300            'port: ' + repr(self.port) + ' ' +\
 8301            'port_override: ' + repr(self.port_override) + ' ' +\
 8302            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8303            'tags: ' + repr(self.tags) + ' ' +\
 8304            '>'
 8305
 8306    def to_dict(self):
 8307        return {
 8308            'bind_interface': self.bind_interface,
 8309            'egress_filter': self.egress_filter,
 8310            'endpoint': self.endpoint,
 8311            'healthy': self.healthy,
 8312            'id': self.id,
 8313            'name': self.name,
 8314            'port': self.port,
 8315            'port_override': self.port_override,
 8316            'secret_store_id': self.secret_store_id,
 8317            'tags': self.tags,
 8318        }
 8319
 8320    @classmethod
 8321    def from_dict(cls, d):
 8322        return cls(
 8323            bind_interface=d.get('bind_interface'),
 8324            egress_filter=d.get('egress_filter'),
 8325            endpoint=d.get('endpoint'),
 8326            healthy=d.get('healthy'),
 8327            id=d.get('id'),
 8328            name=d.get('name'),
 8329            port=d.get('port'),
 8330            port_override=d.get('port_override'),
 8331            secret_store_id=d.get('secret_store_id'),
 8332            tags=d.get('tags'),
 8333        )
 8334
 8335
 8336class NeptuneIAM:
 8337    __slots__ = [
 8338        'access_key',
 8339        'bind_interface',
 8340        'egress_filter',
 8341        'endpoint',
 8342        'healthy',
 8343        'id',
 8344        'name',
 8345        'port',
 8346        'port_override',
 8347        'region',
 8348        'role_arn',
 8349        'role_external_id',
 8350        'secret_access_key',
 8351        'secret_store_id',
 8352        'tags',
 8353    ]
 8354
 8355    def __init__(
 8356        self,
 8357        access_key=None,
 8358        bind_interface=None,
 8359        egress_filter=None,
 8360        endpoint=None,
 8361        healthy=None,
 8362        id=None,
 8363        name=None,
 8364        port=None,
 8365        port_override=None,
 8366        region=None,
 8367        role_arn=None,
 8368        role_external_id=None,
 8369        secret_access_key=None,
 8370        secret_store_id=None,
 8371        tags=None,
 8372    ):
 8373        self.access_key = access_key if access_key is not None else ''
 8374        self.bind_interface = bind_interface if bind_interface is not None else ''
 8375        '''
 8376         Bind interface
 8377        '''
 8378        self.egress_filter = egress_filter if egress_filter is not None else ''
 8379        '''
 8380         A filter applied to the routing logic to pin datasource to nodes.
 8381        '''
 8382        self.endpoint = endpoint if endpoint is not None else ''
 8383        self.healthy = healthy if healthy is not None else False
 8384        '''
 8385         True if the datasource is reachable and the credentials are valid.
 8386        '''
 8387        self.id = id if id is not None else ''
 8388        '''
 8389         Unique identifier of the Resource.
 8390        '''
 8391        self.name = name if name is not None else ''
 8392        '''
 8393         Unique human-readable name of the Resource.
 8394        '''
 8395        self.port = port if port is not None else 0
 8396        self.port_override = port_override if port_override is not None else 0
 8397        self.region = region if region is not None else ''
 8398        self.role_arn = role_arn if role_arn is not None else ''
 8399        self.role_external_id = role_external_id if role_external_id is not None else ''
 8400        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 8401        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8402        '''
 8403         ID of the secret store containing credentials for this resource, if any.
 8404        '''
 8405        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8406        '''
 8407         Tags is a map of key, value pairs.
 8408        '''
 8409
 8410    def __repr__(self):
 8411        return '<sdm.NeptuneIAM ' + \
 8412            'access_key: ' + repr(self.access_key) + ' ' +\
 8413            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8414            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8415            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8416            'healthy: ' + repr(self.healthy) + ' ' +\
 8417            'id: ' + repr(self.id) + ' ' +\
 8418            'name: ' + repr(self.name) + ' ' +\
 8419            'port: ' + repr(self.port) + ' ' +\
 8420            'port_override: ' + repr(self.port_override) + ' ' +\
 8421            'region: ' + repr(self.region) + ' ' +\
 8422            'role_arn: ' + repr(self.role_arn) + ' ' +\
 8423            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 8424            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 8425            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8426            'tags: ' + repr(self.tags) + ' ' +\
 8427            '>'
 8428
 8429    def to_dict(self):
 8430        return {
 8431            'access_key': self.access_key,
 8432            'bind_interface': self.bind_interface,
 8433            'egress_filter': self.egress_filter,
 8434            'endpoint': self.endpoint,
 8435            'healthy': self.healthy,
 8436            'id': self.id,
 8437            'name': self.name,
 8438            'port': self.port,
 8439            'port_override': self.port_override,
 8440            'region': self.region,
 8441            'role_arn': self.role_arn,
 8442            'role_external_id': self.role_external_id,
 8443            'secret_access_key': self.secret_access_key,
 8444            'secret_store_id': self.secret_store_id,
 8445            'tags': self.tags,
 8446        }
 8447
 8448    @classmethod
 8449    def from_dict(cls, d):
 8450        return cls(
 8451            access_key=d.get('access_key'),
 8452            bind_interface=d.get('bind_interface'),
 8453            egress_filter=d.get('egress_filter'),
 8454            endpoint=d.get('endpoint'),
 8455            healthy=d.get('healthy'),
 8456            id=d.get('id'),
 8457            name=d.get('name'),
 8458            port=d.get('port'),
 8459            port_override=d.get('port_override'),
 8460            region=d.get('region'),
 8461            role_arn=d.get('role_arn'),
 8462            role_external_id=d.get('role_external_id'),
 8463            secret_access_key=d.get('secret_access_key'),
 8464            secret_store_id=d.get('secret_store_id'),
 8465            tags=d.get('tags'),
 8466        )
 8467
 8468
 8469class NodeCreateResponse:
 8470    '''
 8471         NodeCreateResponse reports how the Nodes were created in the system.
 8472    '''
 8473    __slots__ = [
 8474        'meta',
 8475        'node',
 8476        'rate_limit',
 8477        'token',
 8478    ]
 8479
 8480    def __init__(
 8481        self,
 8482        meta=None,
 8483        node=None,
 8484        rate_limit=None,
 8485        token=None,
 8486    ):
 8487        self.meta = meta if meta is not None else None
 8488        '''
 8489         Reserved for future use.
 8490        '''
 8491        self.node = node if node is not None else None
 8492        '''
 8493         The created Node.
 8494        '''
 8495        self.rate_limit = rate_limit if rate_limit is not None else None
 8496        '''
 8497         Rate limit information.
 8498        '''
 8499        self.token = token if token is not None else ''
 8500        '''
 8501         The auth token generated for the Node. The Node will use this token to
 8502         authenticate with the strongDM API.
 8503        '''
 8504
 8505    def __repr__(self):
 8506        return '<sdm.NodeCreateResponse ' + \
 8507            'meta: ' + repr(self.meta) + ' ' +\
 8508            'node: ' + repr(self.node) + ' ' +\
 8509            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8510            'token: ' + repr(self.token) + ' ' +\
 8511            '>'
 8512
 8513    def to_dict(self):
 8514        return {
 8515            'meta': self.meta,
 8516            'node': self.node,
 8517            'rate_limit': self.rate_limit,
 8518            'token': self.token,
 8519        }
 8520
 8521    @classmethod
 8522    def from_dict(cls, d):
 8523        return cls(
 8524            meta=d.get('meta'),
 8525            node=d.get('node'),
 8526            rate_limit=d.get('rate_limit'),
 8527            token=d.get('token'),
 8528        )
 8529
 8530
 8531class NodeDeleteResponse:
 8532    '''
 8533         NodeDeleteResponse returns information about a Node that was deleted.
 8534    '''
 8535    __slots__ = [
 8536        'meta',
 8537        'rate_limit',
 8538    ]
 8539
 8540    def __init__(
 8541        self,
 8542        meta=None,
 8543        rate_limit=None,
 8544    ):
 8545        self.meta = meta if meta is not None else None
 8546        '''
 8547         Reserved for future use.
 8548        '''
 8549        self.rate_limit = rate_limit if rate_limit is not None else None
 8550        '''
 8551         Rate limit information.
 8552        '''
 8553
 8554    def __repr__(self):
 8555        return '<sdm.NodeDeleteResponse ' + \
 8556            'meta: ' + repr(self.meta) + ' ' +\
 8557            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8558            '>'
 8559
 8560    def to_dict(self):
 8561        return {
 8562            'meta': self.meta,
 8563            'rate_limit': self.rate_limit,
 8564        }
 8565
 8566    @classmethod
 8567    def from_dict(cls, d):
 8568        return cls(
 8569            meta=d.get('meta'),
 8570            rate_limit=d.get('rate_limit'),
 8571        )
 8572
 8573
 8574class NodeGetResponse:
 8575    '''
 8576         NodeGetResponse returns a requested Node.
 8577    '''
 8578    __slots__ = [
 8579        'meta',
 8580        'node',
 8581        'rate_limit',
 8582    ]
 8583
 8584    def __init__(
 8585        self,
 8586        meta=None,
 8587        node=None,
 8588        rate_limit=None,
 8589    ):
 8590        self.meta = meta if meta is not None else None
 8591        '''
 8592         Reserved for future use.
 8593        '''
 8594        self.node = node if node is not None else None
 8595        '''
 8596         The requested Node.
 8597        '''
 8598        self.rate_limit = rate_limit if rate_limit is not None else None
 8599        '''
 8600         Rate limit information.
 8601        '''
 8602
 8603    def __repr__(self):
 8604        return '<sdm.NodeGetResponse ' + \
 8605            'meta: ' + repr(self.meta) + ' ' +\
 8606            'node: ' + repr(self.node) + ' ' +\
 8607            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8608            '>'
 8609
 8610    def to_dict(self):
 8611        return {
 8612            'meta': self.meta,
 8613            'node': self.node,
 8614            'rate_limit': self.rate_limit,
 8615        }
 8616
 8617    @classmethod
 8618    def from_dict(cls, d):
 8619        return cls(
 8620            meta=d.get('meta'),
 8621            node=d.get('node'),
 8622            rate_limit=d.get('rate_limit'),
 8623        )
 8624
 8625
 8626class NodeUpdateResponse:
 8627    '''
 8628         NodeUpdateResponse returns the fields of a Node after it has been updated by
 8629     a NodeUpdateRequest.
 8630    '''
 8631    __slots__ = [
 8632        'meta',
 8633        'node',
 8634        'rate_limit',
 8635    ]
 8636
 8637    def __init__(
 8638        self,
 8639        meta=None,
 8640        node=None,
 8641        rate_limit=None,
 8642    ):
 8643        self.meta = meta if meta is not None else None
 8644        '''
 8645         Reserved for future use.
 8646        '''
 8647        self.node = node if node is not None else None
 8648        '''
 8649         The updated Node.
 8650        '''
 8651        self.rate_limit = rate_limit if rate_limit is not None else None
 8652        '''
 8653         Rate limit information.
 8654        '''
 8655
 8656    def __repr__(self):
 8657        return '<sdm.NodeUpdateResponse ' + \
 8658            'meta: ' + repr(self.meta) + ' ' +\
 8659            'node: ' + repr(self.node) + ' ' +\
 8660            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8661            '>'
 8662
 8663    def to_dict(self):
 8664        return {
 8665            'meta': self.meta,
 8666            'node': self.node,
 8667            'rate_limit': self.rate_limit,
 8668        }
 8669
 8670    @classmethod
 8671    def from_dict(cls, d):
 8672        return cls(
 8673            meta=d.get('meta'),
 8674            node=d.get('node'),
 8675            rate_limit=d.get('rate_limit'),
 8676        )
 8677
 8678
 8679class Oracle:
 8680    __slots__ = [
 8681        'bind_interface',
 8682        'database',
 8683        'egress_filter',
 8684        'healthy',
 8685        'hostname',
 8686        'id',
 8687        'name',
 8688        'password',
 8689        'port',
 8690        'port_override',
 8691        'secret_store_id',
 8692        'tags',
 8693        'tls_required',
 8694        'username',
 8695    ]
 8696
 8697    def __init__(
 8698        self,
 8699        bind_interface=None,
 8700        database=None,
 8701        egress_filter=None,
 8702        healthy=None,
 8703        hostname=None,
 8704        id=None,
 8705        name=None,
 8706        password=None,
 8707        port=None,
 8708        port_override=None,
 8709        secret_store_id=None,
 8710        tags=None,
 8711        tls_required=None,
 8712        username=None,
 8713    ):
 8714        self.bind_interface = bind_interface if bind_interface is not None else ''
 8715        '''
 8716         Bind interface
 8717        '''
 8718        self.database = database if database is not None else ''
 8719        self.egress_filter = egress_filter if egress_filter is not None else ''
 8720        '''
 8721         A filter applied to the routing logic to pin datasource to nodes.
 8722        '''
 8723        self.healthy = healthy if healthy is not None else False
 8724        '''
 8725         True if the datasource is reachable and the credentials are valid.
 8726        '''
 8727        self.hostname = hostname if hostname is not None else ''
 8728        self.id = id if id is not None else ''
 8729        '''
 8730         Unique identifier of the Resource.
 8731        '''
 8732        self.name = name if name is not None else ''
 8733        '''
 8734         Unique human-readable name of the Resource.
 8735        '''
 8736        self.password = password if password is not None else ''
 8737        self.port = port if port is not None else 0
 8738        self.port_override = port_override if port_override is not None else 0
 8739        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8740        '''
 8741         ID of the secret store containing credentials for this resource, if any.
 8742        '''
 8743        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8744        '''
 8745         Tags is a map of key, value pairs.
 8746        '''
 8747        self.tls_required = tls_required if tls_required is not None else False
 8748        self.username = username if username is not None else ''
 8749
 8750    def __repr__(self):
 8751        return '<sdm.Oracle ' + \
 8752            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8753            'database: ' + repr(self.database) + ' ' +\
 8754            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8755            'healthy: ' + repr(self.healthy) + ' ' +\
 8756            'hostname: ' + repr(self.hostname) + ' ' +\
 8757            'id: ' + repr(self.id) + ' ' +\
 8758            'name: ' + repr(self.name) + ' ' +\
 8759            'password: ' + repr(self.password) + ' ' +\
 8760            'port: ' + repr(self.port) + ' ' +\
 8761            'port_override: ' + repr(self.port_override) + ' ' +\
 8762            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8763            'tags: ' + repr(self.tags) + ' ' +\
 8764            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8765            'username: ' + repr(self.username) + ' ' +\
 8766            '>'
 8767
 8768    def to_dict(self):
 8769        return {
 8770            'bind_interface': self.bind_interface,
 8771            'database': self.database,
 8772            'egress_filter': self.egress_filter,
 8773            'healthy': self.healthy,
 8774            'hostname': self.hostname,
 8775            'id': self.id,
 8776            'name': self.name,
 8777            'password': self.password,
 8778            'port': self.port,
 8779            'port_override': self.port_override,
 8780            'secret_store_id': self.secret_store_id,
 8781            'tags': self.tags,
 8782            'tls_required': self.tls_required,
 8783            'username': self.username,
 8784        }
 8785
 8786    @classmethod
 8787    def from_dict(cls, d):
 8788        return cls(
 8789            bind_interface=d.get('bind_interface'),
 8790            database=d.get('database'),
 8791            egress_filter=d.get('egress_filter'),
 8792            healthy=d.get('healthy'),
 8793            hostname=d.get('hostname'),
 8794            id=d.get('id'),
 8795            name=d.get('name'),
 8796            password=d.get('password'),
 8797            port=d.get('port'),
 8798            port_override=d.get('port_override'),
 8799            secret_store_id=d.get('secret_store_id'),
 8800            tags=d.get('tags'),
 8801            tls_required=d.get('tls_required'),
 8802            username=d.get('username'),
 8803        )
 8804
 8805
 8806class Postgres:
 8807    __slots__ = [
 8808        'bind_interface',
 8809        'database',
 8810        'egress_filter',
 8811        'healthy',
 8812        'hostname',
 8813        'id',
 8814        'name',
 8815        'override_database',
 8816        'password',
 8817        'port',
 8818        'port_override',
 8819        'secret_store_id',
 8820        'tags',
 8821        'username',
 8822    ]
 8823
 8824    def __init__(
 8825        self,
 8826        bind_interface=None,
 8827        database=None,
 8828        egress_filter=None,
 8829        healthy=None,
 8830        hostname=None,
 8831        id=None,
 8832        name=None,
 8833        override_database=None,
 8834        password=None,
 8835        port=None,
 8836        port_override=None,
 8837        secret_store_id=None,
 8838        tags=None,
 8839        username=None,
 8840    ):
 8841        self.bind_interface = bind_interface if bind_interface is not None else ''
 8842        '''
 8843         Bind interface
 8844        '''
 8845        self.database = database if database is not None else ''
 8846        self.egress_filter = egress_filter if egress_filter is not None else ''
 8847        '''
 8848         A filter applied to the routing logic to pin datasource to nodes.
 8849        '''
 8850        self.healthy = healthy if healthy is not None else False
 8851        '''
 8852         True if the datasource is reachable and the credentials are valid.
 8853        '''
 8854        self.hostname = hostname if hostname is not None else ''
 8855        self.id = id if id is not None else ''
 8856        '''
 8857         Unique identifier of the Resource.
 8858        '''
 8859        self.name = name if name is not None else ''
 8860        '''
 8861         Unique human-readable name of the Resource.
 8862        '''
 8863        self.override_database = override_database if override_database is not None else False
 8864        self.password = password if password is not None else ''
 8865        self.port = port if port is not None else 0
 8866        self.port_override = port_override if port_override is not None else 0
 8867        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8868        '''
 8869         ID of the secret store containing credentials for this resource, if any.
 8870        '''
 8871        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8872        '''
 8873         Tags is a map of key, value pairs.
 8874        '''
 8875        self.username = username if username is not None else ''
 8876
 8877    def __repr__(self):
 8878        return '<sdm.Postgres ' + \
 8879            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8880            'database: ' + repr(self.database) + ' ' +\
 8881            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8882            'healthy: ' + repr(self.healthy) + ' ' +\
 8883            'hostname: ' + repr(self.hostname) + ' ' +\
 8884            'id: ' + repr(self.id) + ' ' +\
 8885            'name: ' + repr(self.name) + ' ' +\
 8886            'override_database: ' + repr(self.override_database) + ' ' +\
 8887            'password: ' + repr(self.password) + ' ' +\
 8888            'port: ' + repr(self.port) + ' ' +\
 8889            'port_override: ' + repr(self.port_override) + ' ' +\
 8890            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8891            'tags: ' + repr(self.tags) + ' ' +\
 8892            'username: ' + repr(self.username) + ' ' +\
 8893            '>'
 8894
 8895    def to_dict(self):
 8896        return {
 8897            'bind_interface': self.bind_interface,
 8898            'database': self.database,
 8899            'egress_filter': self.egress_filter,
 8900            'healthy': self.healthy,
 8901            'hostname': self.hostname,
 8902            'id': self.id,
 8903            'name': self.name,
 8904            'override_database': self.override_database,
 8905            'password': self.password,
 8906            'port': self.port,
 8907            'port_override': self.port_override,
 8908            'secret_store_id': self.secret_store_id,
 8909            'tags': self.tags,
 8910            'username': self.username,
 8911        }
 8912
 8913    @classmethod
 8914    def from_dict(cls, d):
 8915        return cls(
 8916            bind_interface=d.get('bind_interface'),
 8917            database=d.get('database'),
 8918            egress_filter=d.get('egress_filter'),
 8919            healthy=d.get('healthy'),
 8920            hostname=d.get('hostname'),
 8921            id=d.get('id'),
 8922            name=d.get('name'),
 8923            override_database=d.get('override_database'),
 8924            password=d.get('password'),
 8925            port=d.get('port'),
 8926            port_override=d.get('port_override'),
 8927            secret_store_id=d.get('secret_store_id'),
 8928            tags=d.get('tags'),
 8929            username=d.get('username'),
 8930        )
 8931
 8932
 8933class Presto:
 8934    __slots__ = [
 8935        'bind_interface',
 8936        'database',
 8937        'egress_filter',
 8938        'healthy',
 8939        'hostname',
 8940        'id',
 8941        'name',
 8942        'password',
 8943        'port',
 8944        'port_override',
 8945        'secret_store_id',
 8946        'tags',
 8947        'tls_required',
 8948        'username',
 8949    ]
 8950
 8951    def __init__(
 8952        self,
 8953        bind_interface=None,
 8954        database=None,
 8955        egress_filter=None,
 8956        healthy=None,
 8957        hostname=None,
 8958        id=None,
 8959        name=None,
 8960        password=None,
 8961        port=None,
 8962        port_override=None,
 8963        secret_store_id=None,
 8964        tags=None,
 8965        tls_required=None,
 8966        username=None,
 8967    ):
 8968        self.bind_interface = bind_interface if bind_interface is not None else ''
 8969        '''
 8970         Bind interface
 8971        '''
 8972        self.database = database if database is not None else ''
 8973        self.egress_filter = egress_filter if egress_filter is not None else ''
 8974        '''
 8975         A filter applied to the routing logic to pin datasource to nodes.
 8976        '''
 8977        self.healthy = healthy if healthy is not None else False
 8978        '''
 8979         True if the datasource is reachable and the credentials are valid.
 8980        '''
 8981        self.hostname = hostname if hostname is not None else ''
 8982        self.id = id if id is not None else ''
 8983        '''
 8984         Unique identifier of the Resource.
 8985        '''
 8986        self.name = name if name is not None else ''
 8987        '''
 8988         Unique human-readable name of the Resource.
 8989        '''
 8990        self.password = password if password is not None else ''
 8991        self.port = port if port is not None else 0
 8992        self.port_override = port_override if port_override is not None else 0
 8993        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8994        '''
 8995         ID of the secret store containing credentials for this resource, if any.
 8996        '''
 8997        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8998        '''
 8999         Tags is a map of key, value pairs.
 9000        '''
 9001        self.tls_required = tls_required if tls_required is not None else False
 9002        self.username = username if username is not None else ''
 9003
 9004    def __repr__(self):
 9005        return '<sdm.Presto ' + \
 9006            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9007            'database: ' + repr(self.database) + ' ' +\
 9008            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9009            'healthy: ' + repr(self.healthy) + ' ' +\
 9010            'hostname: ' + repr(self.hostname) + ' ' +\
 9011            'id: ' + repr(self.id) + ' ' +\
 9012            'name: ' + repr(self.name) + ' ' +\
 9013            'password: ' + repr(self.password) + ' ' +\
 9014            'port: ' + repr(self.port) + ' ' +\
 9015            'port_override: ' + repr(self.port_override) + ' ' +\
 9016            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9017            'tags: ' + repr(self.tags) + ' ' +\
 9018            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9019            'username: ' + repr(self.username) + ' ' +\
 9020            '>'
 9021
 9022    def to_dict(self):
 9023        return {
 9024            'bind_interface': self.bind_interface,
 9025            'database': self.database,
 9026            'egress_filter': self.egress_filter,
 9027            'healthy': self.healthy,
 9028            'hostname': self.hostname,
 9029            'id': self.id,
 9030            'name': self.name,
 9031            'password': self.password,
 9032            'port': self.port,
 9033            'port_override': self.port_override,
 9034            'secret_store_id': self.secret_store_id,
 9035            'tags': self.tags,
 9036            'tls_required': self.tls_required,
 9037            'username': self.username,
 9038        }
 9039
 9040    @classmethod
 9041    def from_dict(cls, d):
 9042        return cls(
 9043            bind_interface=d.get('bind_interface'),
 9044            database=d.get('database'),
 9045            egress_filter=d.get('egress_filter'),
 9046            healthy=d.get('healthy'),
 9047            hostname=d.get('hostname'),
 9048            id=d.get('id'),
 9049            name=d.get('name'),
 9050            password=d.get('password'),
 9051            port=d.get('port'),
 9052            port_override=d.get('port_override'),
 9053            secret_store_id=d.get('secret_store_id'),
 9054            tags=d.get('tags'),
 9055            tls_required=d.get('tls_required'),
 9056            username=d.get('username'),
 9057        )
 9058
 9059
 9060class RDP:
 9061    __slots__ = [
 9062        'bind_interface',
 9063        'downgrade_nla_connections',
 9064        'egress_filter',
 9065        'healthy',
 9066        'hostname',
 9067        'id',
 9068        'name',
 9069        'password',
 9070        'port',
 9071        'port_override',
 9072        'secret_store_id',
 9073        'tags',
 9074        'username',
 9075    ]
 9076
 9077    def __init__(
 9078        self,
 9079        bind_interface=None,
 9080        downgrade_nla_connections=None,
 9081        egress_filter=None,
 9082        healthy=None,
 9083        hostname=None,
 9084        id=None,
 9085        name=None,
 9086        password=None,
 9087        port=None,
 9088        port_override=None,
 9089        secret_store_id=None,
 9090        tags=None,
 9091        username=None,
 9092    ):
 9093        self.bind_interface = bind_interface if bind_interface is not None else ''
 9094        '''
 9095         Bind interface
 9096        '''
 9097        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 9098        self.egress_filter = egress_filter if egress_filter is not None else ''
 9099        '''
 9100         A filter applied to the routing logic to pin datasource to nodes.
 9101        '''
 9102        self.healthy = healthy if healthy is not None else False
 9103        '''
 9104         True if the datasource is reachable and the credentials are valid.
 9105        '''
 9106        self.hostname = hostname if hostname is not None else ''
 9107        self.id = id if id is not None else ''
 9108        '''
 9109         Unique identifier of the Resource.
 9110        '''
 9111        self.name = name if name is not None else ''
 9112        '''
 9113         Unique human-readable name of the Resource.
 9114        '''
 9115        self.password = password if password is not None else ''
 9116        self.port = port if port is not None else 0
 9117        self.port_override = port_override if port_override is not None else 0
 9118        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9119        '''
 9120         ID of the secret store containing credentials for this resource, if any.
 9121        '''
 9122        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9123        '''
 9124         Tags is a map of key, value pairs.
 9125        '''
 9126        self.username = username if username is not None else ''
 9127
 9128    def __repr__(self):
 9129        return '<sdm.RDP ' + \
 9130            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9131            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 9132            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9133            'healthy: ' + repr(self.healthy) + ' ' +\
 9134            'hostname: ' + repr(self.hostname) + ' ' +\
 9135            'id: ' + repr(self.id) + ' ' +\
 9136            'name: ' + repr(self.name) + ' ' +\
 9137            'password: ' + repr(self.password) + ' ' +\
 9138            'port: ' + repr(self.port) + ' ' +\
 9139            'port_override: ' + repr(self.port_override) + ' ' +\
 9140            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9141            'tags: ' + repr(self.tags) + ' ' +\
 9142            'username: ' + repr(self.username) + ' ' +\
 9143            '>'
 9144
 9145    def to_dict(self):
 9146        return {
 9147            'bind_interface': self.bind_interface,
 9148            'downgrade_nla_connections': self.downgrade_nla_connections,
 9149            'egress_filter': self.egress_filter,
 9150            'healthy': self.healthy,
 9151            'hostname': self.hostname,
 9152            'id': self.id,
 9153            'name': self.name,
 9154            'password': self.password,
 9155            'port': self.port,
 9156            'port_override': self.port_override,
 9157            'secret_store_id': self.secret_store_id,
 9158            'tags': self.tags,
 9159            'username': self.username,
 9160        }
 9161
 9162    @classmethod
 9163    def from_dict(cls, d):
 9164        return cls(
 9165            bind_interface=d.get('bind_interface'),
 9166            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 9167            egress_filter=d.get('egress_filter'),
 9168            healthy=d.get('healthy'),
 9169            hostname=d.get('hostname'),
 9170            id=d.get('id'),
 9171            name=d.get('name'),
 9172            password=d.get('password'),
 9173            port=d.get('port'),
 9174            port_override=d.get('port_override'),
 9175            secret_store_id=d.get('secret_store_id'),
 9176            tags=d.get('tags'),
 9177            username=d.get('username'),
 9178        )
 9179
 9180
 9181class RabbitMQAMQP091:
 9182    __slots__ = [
 9183        'bind_interface',
 9184        'egress_filter',
 9185        'healthy',
 9186        'hostname',
 9187        'id',
 9188        'name',
 9189        'password',
 9190        'port',
 9191        'port_override',
 9192        'secret_store_id',
 9193        'tags',
 9194        'tls_required',
 9195        'username',
 9196    ]
 9197
 9198    def __init__(
 9199        self,
 9200        bind_interface=None,
 9201        egress_filter=None,
 9202        healthy=None,
 9203        hostname=None,
 9204        id=None,
 9205        name=None,
 9206        password=None,
 9207        port=None,
 9208        port_override=None,
 9209        secret_store_id=None,
 9210        tags=None,
 9211        tls_required=None,
 9212        username=None,
 9213    ):
 9214        self.bind_interface = bind_interface if bind_interface is not None else ''
 9215        '''
 9216         Bind interface
 9217        '''
 9218        self.egress_filter = egress_filter if egress_filter is not None else ''
 9219        '''
 9220         A filter applied to the routing logic to pin datasource to nodes.
 9221        '''
 9222        self.healthy = healthy if healthy is not None else False
 9223        '''
 9224         True if the datasource is reachable and the credentials are valid.
 9225        '''
 9226        self.hostname = hostname if hostname is not None else ''
 9227        self.id = id if id is not None else ''
 9228        '''
 9229         Unique identifier of the Resource.
 9230        '''
 9231        self.name = name if name is not None else ''
 9232        '''
 9233         Unique human-readable name of the Resource.
 9234        '''
 9235        self.password = password if password is not None else ''
 9236        self.port = port if port is not None else 0
 9237        self.port_override = port_override if port_override is not None else 0
 9238        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9239        '''
 9240         ID of the secret store containing credentials for this resource, if any.
 9241        '''
 9242        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9243        '''
 9244         Tags is a map of key, value pairs.
 9245        '''
 9246        self.tls_required = tls_required if tls_required is not None else False
 9247        self.username = username if username is not None else ''
 9248
 9249    def __repr__(self):
 9250        return '<sdm.RabbitMQAMQP091 ' + \
 9251            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9252            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9253            'healthy: ' + repr(self.healthy) + ' ' +\
 9254            'hostname: ' + repr(self.hostname) + ' ' +\
 9255            'id: ' + repr(self.id) + ' ' +\
 9256            'name: ' + repr(self.name) + ' ' +\
 9257            'password: ' + repr(self.password) + ' ' +\
 9258            'port: ' + repr(self.port) + ' ' +\
 9259            'port_override: ' + repr(self.port_override) + ' ' +\
 9260            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9261            'tags: ' + repr(self.tags) + ' ' +\
 9262            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9263            'username: ' + repr(self.username) + ' ' +\
 9264            '>'
 9265
 9266    def to_dict(self):
 9267        return {
 9268            'bind_interface': self.bind_interface,
 9269            'egress_filter': self.egress_filter,
 9270            'healthy': self.healthy,
 9271            'hostname': self.hostname,
 9272            'id': self.id,
 9273            'name': self.name,
 9274            'password': self.password,
 9275            'port': self.port,
 9276            'port_override': self.port_override,
 9277            'secret_store_id': self.secret_store_id,
 9278            'tags': self.tags,
 9279            'tls_required': self.tls_required,
 9280            'username': self.username,
 9281        }
 9282
 9283    @classmethod
 9284    def from_dict(cls, d):
 9285        return cls(
 9286            bind_interface=d.get('bind_interface'),
 9287            egress_filter=d.get('egress_filter'),
 9288            healthy=d.get('healthy'),
 9289            hostname=d.get('hostname'),
 9290            id=d.get('id'),
 9291            name=d.get('name'),
 9292            password=d.get('password'),
 9293            port=d.get('port'),
 9294            port_override=d.get('port_override'),
 9295            secret_store_id=d.get('secret_store_id'),
 9296            tags=d.get('tags'),
 9297            tls_required=d.get('tls_required'),
 9298            username=d.get('username'),
 9299        )
 9300
 9301
 9302class RateLimitMetadata:
 9303    '''
 9304         RateLimitMetadata contains information about remaining requests avaialable
 9305     to the user over some timeframe.
 9306    '''
 9307    __slots__ = [
 9308        'bucket',
 9309        'limit',
 9310        'remaining',
 9311        'reset_at',
 9312    ]
 9313
 9314    def __init__(
 9315        self,
 9316        bucket=None,
 9317        limit=None,
 9318        remaining=None,
 9319        reset_at=None,
 9320    ):
 9321        self.bucket = bucket if bucket is not None else ''
 9322        '''
 9323         The bucket this user/token is associated with, which may be shared between
 9324         multiple users/tokens.
 9325        '''
 9326        self.limit = limit if limit is not None else 0
 9327        '''
 9328         How many total requests the user/token is authorized to make before being
 9329         rate limited.
 9330        '''
 9331        self.remaining = remaining if remaining is not None else 0
 9332        '''
 9333         How many remaining requests out of the limit are still avaialable.
 9334        '''
 9335        self.reset_at = reset_at if reset_at is not None else None
 9336        '''
 9337         The time when remaining will be reset to limit.
 9338        '''
 9339
 9340    def __repr__(self):
 9341        return '<sdm.RateLimitMetadata ' + \
 9342            'bucket: ' + repr(self.bucket) + ' ' +\
 9343            'limit: ' + repr(self.limit) + ' ' +\
 9344            'remaining: ' + repr(self.remaining) + ' ' +\
 9345            'reset_at: ' + repr(self.reset_at) + ' ' +\
 9346            '>'
 9347
 9348    def to_dict(self):
 9349        return {
 9350            'bucket': self.bucket,
 9351            'limit': self.limit,
 9352            'remaining': self.remaining,
 9353            'reset_at': self.reset_at,
 9354        }
 9355
 9356    @classmethod
 9357    def from_dict(cls, d):
 9358        return cls(
 9359            bucket=d.get('bucket'),
 9360            limit=d.get('limit'),
 9361            remaining=d.get('remaining'),
 9362            reset_at=d.get('reset_at'),
 9363        )
 9364
 9365
 9366class RawTCP:
 9367    __slots__ = [
 9368        'bind_interface',
 9369        'egress_filter',
 9370        'healthy',
 9371        'hostname',
 9372        'id',
 9373        'name',
 9374        'port',
 9375        'port_override',
 9376        'secret_store_id',
 9377        'tags',
 9378    ]
 9379
 9380    def __init__(
 9381        self,
 9382        bind_interface=None,
 9383        egress_filter=None,
 9384        healthy=None,
 9385        hostname=None,
 9386        id=None,
 9387        name=None,
 9388        port=None,
 9389        port_override=None,
 9390        secret_store_id=None,
 9391        tags=None,
 9392    ):
 9393        self.bind_interface = bind_interface if bind_interface is not None else ''
 9394        '''
 9395         Bind interface
 9396        '''
 9397        self.egress_filter = egress_filter if egress_filter is not None else ''
 9398        '''
 9399         A filter applied to the routing logic to pin datasource to nodes.
 9400        '''
 9401        self.healthy = healthy if healthy is not None else False
 9402        '''
 9403         True if the datasource is reachable and the credentials are valid.
 9404        '''
 9405        self.hostname = hostname if hostname is not None else ''
 9406        self.id = id if id is not None else ''
 9407        '''
 9408         Unique identifier of the Resource.
 9409        '''
 9410        self.name = name if name is not None else ''
 9411        '''
 9412         Unique human-readable name of the Resource.
 9413        '''
 9414        self.port = port if port is not None else 0
 9415        self.port_override = port_override if port_override is not None else 0
 9416        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9417        '''
 9418         ID of the secret store containing credentials for this resource, if any.
 9419        '''
 9420        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9421        '''
 9422         Tags is a map of key, value pairs.
 9423        '''
 9424
 9425    def __repr__(self):
 9426        return '<sdm.RawTCP ' + \
 9427            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9428            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9429            'healthy: ' + repr(self.healthy) + ' ' +\
 9430            'hostname: ' + repr(self.hostname) + ' ' +\
 9431            'id: ' + repr(self.id) + ' ' +\
 9432            'name: ' + repr(self.name) + ' ' +\
 9433            'port: ' + repr(self.port) + ' ' +\
 9434            'port_override: ' + repr(self.port_override) + ' ' +\
 9435            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9436            'tags: ' + repr(self.tags) + ' ' +\
 9437            '>'
 9438
 9439    def to_dict(self):
 9440        return {
 9441            'bind_interface': self.bind_interface,
 9442            'egress_filter': self.egress_filter,
 9443            'healthy': self.healthy,
 9444            'hostname': self.hostname,
 9445            'id': self.id,
 9446            'name': self.name,
 9447            'port': self.port,
 9448            'port_override': self.port_override,
 9449            'secret_store_id': self.secret_store_id,
 9450            'tags': self.tags,
 9451        }
 9452
 9453    @classmethod
 9454    def from_dict(cls, d):
 9455        return cls(
 9456            bind_interface=d.get('bind_interface'),
 9457            egress_filter=d.get('egress_filter'),
 9458            healthy=d.get('healthy'),
 9459            hostname=d.get('hostname'),
 9460            id=d.get('id'),
 9461            name=d.get('name'),
 9462            port=d.get('port'),
 9463            port_override=d.get('port_override'),
 9464            secret_store_id=d.get('secret_store_id'),
 9465            tags=d.get('tags'),
 9466        )
 9467
 9468
 9469class Redis:
 9470    __slots__ = [
 9471        'bind_interface',
 9472        'egress_filter',
 9473        'healthy',
 9474        'hostname',
 9475        'id',
 9476        'name',
 9477        'password',
 9478        'port',
 9479        'port_override',
 9480        'secret_store_id',
 9481        'tags',
 9482    ]
 9483
 9484    def __init__(
 9485        self,
 9486        bind_interface=None,
 9487        egress_filter=None,
 9488        healthy=None,
 9489        hostname=None,
 9490        id=None,
 9491        name=None,
 9492        password=None,
 9493        port=None,
 9494        port_override=None,
 9495        secret_store_id=None,
 9496        tags=None,
 9497    ):
 9498        self.bind_interface = bind_interface if bind_interface is not None else ''
 9499        '''
 9500         Bind interface
 9501        '''
 9502        self.egress_filter = egress_filter if egress_filter is not None else ''
 9503        '''
 9504         A filter applied to the routing logic to pin datasource to nodes.
 9505        '''
 9506        self.healthy = healthy if healthy is not None else False
 9507        '''
 9508         True if the datasource is reachable and the credentials are valid.
 9509        '''
 9510        self.hostname = hostname if hostname is not None else ''
 9511        self.id = id if id is not None else ''
 9512        '''
 9513         Unique identifier of the Resource.
 9514        '''
 9515        self.name = name if name is not None else ''
 9516        '''
 9517         Unique human-readable name of the Resource.
 9518        '''
 9519        self.password = password if password is not None else ''
 9520        self.port = port if port is not None else 0
 9521        self.port_override = port_override if port_override is not None else 0
 9522        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9523        '''
 9524         ID of the secret store containing credentials for this resource, if any.
 9525        '''
 9526        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9527        '''
 9528         Tags is a map of key, value pairs.
 9529        '''
 9530
 9531    def __repr__(self):
 9532        return '<sdm.Redis ' + \
 9533            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9534            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9535            'healthy: ' + repr(self.healthy) + ' ' +\
 9536            'hostname: ' + repr(self.hostname) + ' ' +\
 9537            'id: ' + repr(self.id) + ' ' +\
 9538            'name: ' + repr(self.name) + ' ' +\
 9539            'password: ' + repr(self.password) + ' ' +\
 9540            'port: ' + repr(self.port) + ' ' +\
 9541            'port_override: ' + repr(self.port_override) + ' ' +\
 9542            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9543            'tags: ' + repr(self.tags) + ' ' +\
 9544            '>'
 9545
 9546    def to_dict(self):
 9547        return {
 9548            'bind_interface': self.bind_interface,
 9549            'egress_filter': self.egress_filter,
 9550            'healthy': self.healthy,
 9551            'hostname': self.hostname,
 9552            'id': self.id,
 9553            'name': self.name,
 9554            'password': self.password,
 9555            'port': self.port,
 9556            'port_override': self.port_override,
 9557            'secret_store_id': self.secret_store_id,
 9558            'tags': self.tags,
 9559        }
 9560
 9561    @classmethod
 9562    def from_dict(cls, d):
 9563        return cls(
 9564            bind_interface=d.get('bind_interface'),
 9565            egress_filter=d.get('egress_filter'),
 9566            healthy=d.get('healthy'),
 9567            hostname=d.get('hostname'),
 9568            id=d.get('id'),
 9569            name=d.get('name'),
 9570            password=d.get('password'),
 9571            port=d.get('port'),
 9572            port_override=d.get('port_override'),
 9573            secret_store_id=d.get('secret_store_id'),
 9574            tags=d.get('tags'),
 9575        )
 9576
 9577
 9578class Redshift:
 9579    __slots__ = [
 9580        'bind_interface',
 9581        'database',
 9582        'egress_filter',
 9583        'healthy',
 9584        'hostname',
 9585        'id',
 9586        'name',
 9587        'override_database',
 9588        'password',
 9589        'port',
 9590        'port_override',
 9591        'secret_store_id',
 9592        'tags',
 9593        'username',
 9594    ]
 9595
 9596    def __init__(
 9597        self,
 9598        bind_interface=None,
 9599        database=None,
 9600        egress_filter=None,
 9601        healthy=None,
 9602        hostname=None,
 9603        id=None,
 9604        name=None,
 9605        override_database=None,
 9606        password=None,
 9607        port=None,
 9608        port_override=None,
 9609        secret_store_id=None,
 9610        tags=None,
 9611        username=None,
 9612    ):
 9613        self.bind_interface = bind_interface if bind_interface is not None else ''
 9614        '''
 9615         Bind interface
 9616        '''
 9617        self.database = database if database is not None else ''
 9618        self.egress_filter = egress_filter if egress_filter is not None else ''
 9619        '''
 9620         A filter applied to the routing logic to pin datasource to nodes.
 9621        '''
 9622        self.healthy = healthy if healthy is not None else False
 9623        '''
 9624         True if the datasource is reachable and the credentials are valid.
 9625        '''
 9626        self.hostname = hostname if hostname is not None else ''
 9627        self.id = id if id is not None else ''
 9628        '''
 9629         Unique identifier of the Resource.
 9630        '''
 9631        self.name = name if name is not None else ''
 9632        '''
 9633         Unique human-readable name of the Resource.
 9634        '''
 9635        self.override_database = override_database if override_database is not None else False
 9636        self.password = password if password is not None else ''
 9637        self.port = port if port is not None else 0
 9638        self.port_override = port_override if port_override is not None else 0
 9639        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9640        '''
 9641         ID of the secret store containing credentials for this resource, if any.
 9642        '''
 9643        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9644        '''
 9645         Tags is a map of key, value pairs.
 9646        '''
 9647        self.username = username if username is not None else ''
 9648
 9649    def __repr__(self):
 9650        return '<sdm.Redshift ' + \
 9651            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9652            'database: ' + repr(self.database) + ' ' +\
 9653            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9654            'healthy: ' + repr(self.healthy) + ' ' +\
 9655            'hostname: ' + repr(self.hostname) + ' ' +\
 9656            'id: ' + repr(self.id) + ' ' +\
 9657            'name: ' + repr(self.name) + ' ' +\
 9658            'override_database: ' + repr(self.override_database) + ' ' +\
 9659            'password: ' + repr(self.password) + ' ' +\
 9660            'port: ' + repr(self.port) + ' ' +\
 9661            'port_override: ' + repr(self.port_override) + ' ' +\
 9662            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9663            'tags: ' + repr(self.tags) + ' ' +\
 9664            'username: ' + repr(self.username) + ' ' +\
 9665            '>'
 9666
 9667    def to_dict(self):
 9668        return {
 9669            'bind_interface': self.bind_interface,
 9670            'database': self.database,
 9671            'egress_filter': self.egress_filter,
 9672            'healthy': self.healthy,
 9673            'hostname': self.hostname,
 9674            'id': self.id,
 9675            'name': self.name,
 9676            'override_database': self.override_database,
 9677            'password': self.password,
 9678            'port': self.port,
 9679            'port_override': self.port_override,
 9680            'secret_store_id': self.secret_store_id,
 9681            'tags': self.tags,
 9682            'username': self.username,
 9683        }
 9684
 9685    @classmethod
 9686    def from_dict(cls, d):
 9687        return cls(
 9688            bind_interface=d.get('bind_interface'),
 9689            database=d.get('database'),
 9690            egress_filter=d.get('egress_filter'),
 9691            healthy=d.get('healthy'),
 9692            hostname=d.get('hostname'),
 9693            id=d.get('id'),
 9694            name=d.get('name'),
 9695            override_database=d.get('override_database'),
 9696            password=d.get('password'),
 9697            port=d.get('port'),
 9698            port_override=d.get('port_override'),
 9699            secret_store_id=d.get('secret_store_id'),
 9700            tags=d.get('tags'),
 9701            username=d.get('username'),
 9702        )
 9703
 9704
 9705class Relay:
 9706    '''
 9707         Relay represents a StrongDM CLI installation running in relay mode.
 9708    '''
 9709    __slots__ = [
 9710        'device',
 9711        'gateway_filter',
 9712        'id',
 9713        'location',
 9714        'name',
 9715        'state',
 9716        'tags',
 9717        'version',
 9718    ]
 9719
 9720    def __init__(
 9721        self,
 9722        device=None,
 9723        gateway_filter=None,
 9724        id=None,
 9725        location=None,
 9726        name=None,
 9727        state=None,
 9728        tags=None,
 9729        version=None,
 9730    ):
 9731        self.device = device if device is not None else ''
 9732        '''
 9733         Device is a read only device name uploaded by the gateway process when 
 9734         it comes online.
 9735        '''
 9736        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 9737        '''
 9738         GatewayFilter can be used to restrict the peering between relays and
 9739         gateways.
 9740        '''
 9741        self.id = id if id is not None else ''
 9742        '''
 9743         Unique identifier of the Relay.
 9744        '''
 9745        self.location = location if location is not None else ''
 9746        '''
 9747         Location is a read only network location uploaded by the gateway process
 9748         when it comes online.
 9749        '''
 9750        self.name = name if name is not None else ''
 9751        '''
 9752         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 9753        '''
 9754        self.state = state if state is not None else ''
 9755        '''
 9756         The current state of the relay. One of: "new", "verifying_restart",
 9757         "awaiting_restart", "restarting", "started", "stopped", "dead",
 9758         "unknown".
 9759        '''
 9760        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9761        '''
 9762         Tags is a map of key, value pairs.
 9763        '''
 9764        self.version = version if version is not None else ''
 9765        '''
 9766         Version is a read only sdm binary version uploaded by the gateway process
 9767         when it comes online.
 9768        '''
 9769
 9770    def __repr__(self):
 9771        return '<sdm.Relay ' + \
 9772            'device: ' + repr(self.device) + ' ' +\
 9773            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 9774            'id: ' + repr(self.id) + ' ' +\
 9775            'location: ' + repr(self.location) + ' ' +\
 9776            'name: ' + repr(self.name) + ' ' +\
 9777            'state: ' + repr(self.state) + ' ' +\
 9778            'tags: ' + repr(self.tags) + ' ' +\
 9779            'version: ' + repr(self.version) + ' ' +\
 9780            '>'
 9781
 9782    def to_dict(self):
 9783        return {
 9784            'device': self.device,
 9785            'gateway_filter': self.gateway_filter,
 9786            'id': self.id,
 9787            'location': self.location,
 9788            'name': self.name,
 9789            'state': self.state,
 9790            'tags': self.tags,
 9791            'version': self.version,
 9792        }
 9793
 9794    @classmethod
 9795    def from_dict(cls, d):
 9796        return cls(
 9797            device=d.get('device'),
 9798            gateway_filter=d.get('gateway_filter'),
 9799            id=d.get('id'),
 9800            location=d.get('location'),
 9801            name=d.get('name'),
 9802            state=d.get('state'),
 9803            tags=d.get('tags'),
 9804            version=d.get('version'),
 9805        )
 9806
 9807
 9808class RemoteIdentity:
 9809    '''
 9810         RemoteIdentities define the username to be used for a specific account
 9811     when connecting to a remote resource using that group.
 9812    '''
 9813    __slots__ = [
 9814        'account_id',
 9815        'id',
 9816        'remote_identity_group_id',
 9817        'username',
 9818    ]
 9819
 9820    def __init__(
 9821        self,
 9822        account_id=None,
 9823        id=None,
 9824        remote_identity_group_id=None,
 9825        username=None,
 9826    ):
 9827        self.account_id = account_id if account_id is not None else ''
 9828        '''
 9829         The account for this remote identity.
 9830        '''
 9831        self.id = id if id is not None else ''
 9832        '''
 9833         Unique identifier of the RemoteIdentity.
 9834        '''
 9835        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 9836        '''
 9837         The remote identity group.
 9838        '''
 9839        self.username = username if username is not None else ''
 9840        '''
 9841         The username to be used as the remote identity for this account.
 9842        '''
 9843
 9844    def __repr__(self):
 9845        return '<sdm.RemoteIdentity ' + \
 9846            'account_id: ' + repr(self.account_id) + ' ' +\
 9847            'id: ' + repr(self.id) + ' ' +\
 9848            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 9849            'username: ' + repr(self.username) + ' ' +\
 9850            '>'
 9851
 9852    def to_dict(self):
 9853        return {
 9854            'account_id': self.account_id,
 9855            'id': self.id,
 9856            'remote_identity_group_id': self.remote_identity_group_id,
 9857            'username': self.username,
 9858        }
 9859
 9860    @classmethod
 9861    def from_dict(cls, d):
 9862        return cls(
 9863            account_id=d.get('account_id'),
 9864            id=d.get('id'),
 9865            remote_identity_group_id=d.get('remote_identity_group_id'),
 9866            username=d.get('username'),
 9867        )
 9868
 9869
 9870class RemoteIdentityCreateResponse:
 9871    '''
 9872         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
 9873    '''
 9874    __slots__ = [
 9875        'meta',
 9876        'rate_limit',
 9877        'remote_identity',
 9878    ]
 9879
 9880    def __init__(
 9881        self,
 9882        meta=None,
 9883        rate_limit=None,
 9884        remote_identity=None,
 9885    ):
 9886        self.meta = meta if meta is not None else None
 9887        '''
 9888         Reserved for future use.
 9889        '''
 9890        self.rate_limit = rate_limit if rate_limit is not None else None
 9891        '''
 9892         Rate limit information.
 9893        '''
 9894        self.remote_identity = remote_identity if remote_identity is not None else None
 9895        '''
 9896         The created RemoteIdentity.
 9897        '''
 9898
 9899    def __repr__(self):
 9900        return '<sdm.RemoteIdentityCreateResponse ' + \
 9901            'meta: ' + repr(self.meta) + ' ' +\
 9902            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9903            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9904            '>'
 9905
 9906    def to_dict(self):
 9907        return {
 9908            'meta': self.meta,
 9909            'rate_limit': self.rate_limit,
 9910            'remote_identity': self.remote_identity,
 9911        }
 9912
 9913    @classmethod
 9914    def from_dict(cls, d):
 9915        return cls(
 9916            meta=d.get('meta'),
 9917            rate_limit=d.get('rate_limit'),
 9918            remote_identity=d.get('remote_identity'),
 9919        )
 9920
 9921
 9922class RemoteIdentityDeleteResponse:
 9923    '''
 9924         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
 9925    '''
 9926    __slots__ = [
 9927        'meta',
 9928        'rate_limit',
 9929    ]
 9930
 9931    def __init__(
 9932        self,
 9933        meta=None,
 9934        rate_limit=None,
 9935    ):
 9936        self.meta = meta if meta is not None else None
 9937        '''
 9938         Reserved for future use.
 9939        '''
 9940        self.rate_limit = rate_limit if rate_limit is not None else None
 9941        '''
 9942         Rate limit information.
 9943        '''
 9944
 9945    def __repr__(self):
 9946        return '<sdm.RemoteIdentityDeleteResponse ' + \
 9947            'meta: ' + repr(self.meta) + ' ' +\
 9948            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9949            '>'
 9950
 9951    def to_dict(self):
 9952        return {
 9953            'meta': self.meta,
 9954            'rate_limit': self.rate_limit,
 9955        }
 9956
 9957    @classmethod
 9958    def from_dict(cls, d):
 9959        return cls(
 9960            meta=d.get('meta'),
 9961            rate_limit=d.get('rate_limit'),
 9962        )
 9963
 9964
 9965class RemoteIdentityGetResponse:
 9966    '''
 9967         RemoteIdentityGetResponse returns a requested RemoteIdentity.
 9968    '''
 9969    __slots__ = [
 9970        'meta',
 9971        'rate_limit',
 9972        'remote_identity',
 9973    ]
 9974
 9975    def __init__(
 9976        self,
 9977        meta=None,
 9978        rate_limit=None,
 9979        remote_identity=None,
 9980    ):
 9981        self.meta = meta if meta is not None else None
 9982        '''
 9983         Reserved for future use.
 9984        '''
 9985        self.rate_limit = rate_limit if rate_limit is not None else None
 9986        '''
 9987         Rate limit information.
 9988        '''
 9989        self.remote_identity = remote_identity if remote_identity is not None else None
 9990        '''
 9991         The requested RemoteIdentity.
 9992        '''
 9993
 9994    def __repr__(self):
 9995        return '<sdm.RemoteIdentityGetResponse ' + \
 9996            'meta: ' + repr(self.meta) + ' ' +\
 9997            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9998            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
 9999            '>'
10000
10001    def to_dict(self):
10002        return {
10003            'meta': self.meta,
10004            'rate_limit': self.rate_limit,
10005            'remote_identity': self.remote_identity,
10006        }
10007
10008    @classmethod
10009    def from_dict(cls, d):
10010        return cls(
10011            meta=d.get('meta'),
10012            rate_limit=d.get('rate_limit'),
10013            remote_identity=d.get('remote_identity'),
10014        )
10015
10016
10017class RemoteIdentityGroup:
10018    '''
10019         A RemoteIdentityGroup defines a group of remote identities.
10020    '''
10021    __slots__ = [
10022        'id',
10023        'name',
10024    ]
10025
10026    def __init__(
10027        self,
10028        id=None,
10029        name=None,
10030    ):
10031        self.id = id if id is not None else ''
10032        '''
10033         Unique identifier of the RemoteIdentityGroup.
10034        '''
10035        self.name = name if name is not None else ''
10036        '''
10037         Unique human-readable name of the RemoteIdentityGroup.
10038        '''
10039
10040    def __repr__(self):
10041        return '<sdm.RemoteIdentityGroup ' + \
10042            'id: ' + repr(self.id) + ' ' +\
10043            'name: ' + repr(self.name) + ' ' +\
10044            '>'
10045
10046    def to_dict(self):
10047        return {
10048            'id': self.id,
10049            'name': self.name,
10050        }
10051
10052    @classmethod
10053    def from_dict(cls, d):
10054        return cls(
10055            id=d.get('id'),
10056            name=d.get('name'),
10057        )
10058
10059
10060class RemoteIdentityGroupGetResponse:
10061    '''
10062         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10063    '''
10064    __slots__ = [
10065        'meta',
10066        'rate_limit',
10067        'remote_identity_group',
10068    ]
10069
10070    def __init__(
10071        self,
10072        meta=None,
10073        rate_limit=None,
10074        remote_identity_group=None,
10075    ):
10076        self.meta = meta if meta is not None else None
10077        '''
10078         Reserved for future use.
10079        '''
10080        self.rate_limit = rate_limit if rate_limit is not None else None
10081        '''
10082         Rate limit information.
10083        '''
10084        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10085        '''
10086         The requested RemoteIdentityGroup.
10087        '''
10088
10089    def __repr__(self):
10090        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10091            'meta: ' + repr(self.meta) + ' ' +\
10092            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10093            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10094            '>'
10095
10096    def to_dict(self):
10097        return {
10098            'meta': self.meta,
10099            'rate_limit': self.rate_limit,
10100            'remote_identity_group': self.remote_identity_group,
10101        }
10102
10103    @classmethod
10104    def from_dict(cls, d):
10105        return cls(
10106            meta=d.get('meta'),
10107            rate_limit=d.get('rate_limit'),
10108            remote_identity_group=d.get('remote_identity_group'),
10109        )
10110
10111
10112class RemoteIdentityUpdateResponse:
10113    '''
10114         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10115     a RemoteIdentityUpdateRequest.
10116    '''
10117    __slots__ = [
10118        'meta',
10119        'rate_limit',
10120        'remote_identity',
10121    ]
10122
10123    def __init__(
10124        self,
10125        meta=None,
10126        rate_limit=None,
10127        remote_identity=None,
10128    ):
10129        self.meta = meta if meta is not None else None
10130        '''
10131         Reserved for future use.
10132        '''
10133        self.rate_limit = rate_limit if rate_limit is not None else None
10134        '''
10135         Rate limit information.
10136        '''
10137        self.remote_identity = remote_identity if remote_identity is not None else None
10138        '''
10139         The updated RemoteIdentity.
10140        '''
10141
10142    def __repr__(self):
10143        return '<sdm.RemoteIdentityUpdateResponse ' + \
10144            'meta: ' + repr(self.meta) + ' ' +\
10145            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10146            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10147            '>'
10148
10149    def to_dict(self):
10150        return {
10151            'meta': self.meta,
10152            'rate_limit': self.rate_limit,
10153            'remote_identity': self.remote_identity,
10154        }
10155
10156    @classmethod
10157    def from_dict(cls, d):
10158        return cls(
10159            meta=d.get('meta'),
10160            rate_limit=d.get('rate_limit'),
10161            remote_identity=d.get('remote_identity'),
10162        )
10163
10164
10165class ResourceCreateResponse:
10166    '''
10167         ResourceCreateResponse reports how the Resources were created in the system.
10168    '''
10169    __slots__ = [
10170        'meta',
10171        'rate_limit',
10172        'resource',
10173    ]
10174
10175    def __init__(
10176        self,
10177        meta=None,
10178        rate_limit=None,
10179        resource=None,
10180    ):
10181        self.meta = meta if meta is not None else None
10182        '''
10183         Reserved for future use.
10184        '''
10185        self.rate_limit = rate_limit if rate_limit is not None else None
10186        '''
10187         Rate limit information.
10188        '''
10189        self.resource = resource if resource is not None else None
10190        '''
10191         The created Resource.
10192        '''
10193
10194    def __repr__(self):
10195        return '<sdm.ResourceCreateResponse ' + \
10196            'meta: ' + repr(self.meta) + ' ' +\
10197            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10198            'resource: ' + repr(self.resource) + ' ' +\
10199            '>'
10200
10201    def to_dict(self):
10202        return {
10203            'meta': self.meta,
10204            'rate_limit': self.rate_limit,
10205            'resource': self.resource,
10206        }
10207
10208    @classmethod
10209    def from_dict(cls, d):
10210        return cls(
10211            meta=d.get('meta'),
10212            rate_limit=d.get('rate_limit'),
10213            resource=d.get('resource'),
10214        )
10215
10216
10217class ResourceDeleteResponse:
10218    '''
10219         ResourceDeleteResponse returns information about a Resource that was deleted.
10220    '''
10221    __slots__ = [
10222        'meta',
10223        'rate_limit',
10224    ]
10225
10226    def __init__(
10227        self,
10228        meta=None,
10229        rate_limit=None,
10230    ):
10231        self.meta = meta if meta is not None else None
10232        '''
10233         Reserved for future use.
10234        '''
10235        self.rate_limit = rate_limit if rate_limit is not None else None
10236        '''
10237         Rate limit information.
10238        '''
10239
10240    def __repr__(self):
10241        return '<sdm.ResourceDeleteResponse ' + \
10242            'meta: ' + repr(self.meta) + ' ' +\
10243            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10244            '>'
10245
10246    def to_dict(self):
10247        return {
10248            'meta': self.meta,
10249            'rate_limit': self.rate_limit,
10250        }
10251
10252    @classmethod
10253    def from_dict(cls, d):
10254        return cls(
10255            meta=d.get('meta'),
10256            rate_limit=d.get('rate_limit'),
10257        )
10258
10259
10260class ResourceGetResponse:
10261    '''
10262         ResourceGetResponse returns a requested Resource.
10263    '''
10264    __slots__ = [
10265        'meta',
10266        'rate_limit',
10267        'resource',
10268    ]
10269
10270    def __init__(
10271        self,
10272        meta=None,
10273        rate_limit=None,
10274        resource=None,
10275    ):
10276        self.meta = meta if meta is not None else None
10277        '''
10278         Reserved for future use.
10279        '''
10280        self.rate_limit = rate_limit if rate_limit is not None else None
10281        '''
10282         Rate limit information.
10283        '''
10284        self.resource = resource if resource is not None else None
10285        '''
10286         The requested Resource.
10287        '''
10288
10289    def __repr__(self):
10290        return '<sdm.ResourceGetResponse ' + \
10291            'meta: ' + repr(self.meta) + ' ' +\
10292            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10293            'resource: ' + repr(self.resource) + ' ' +\
10294            '>'
10295
10296    def to_dict(self):
10297        return {
10298            'meta': self.meta,
10299            'rate_limit': self.rate_limit,
10300            'resource': self.resource,
10301        }
10302
10303    @classmethod
10304    def from_dict(cls, d):
10305        return cls(
10306            meta=d.get('meta'),
10307            rate_limit=d.get('rate_limit'),
10308            resource=d.get('resource'),
10309        )
10310
10311
10312class ResourceUpdateResponse:
10313    '''
10314         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10315     a ResourceUpdateRequest.
10316    '''
10317    __slots__ = [
10318        'meta',
10319        'rate_limit',
10320        'resource',
10321    ]
10322
10323    def __init__(
10324        self,
10325        meta=None,
10326        rate_limit=None,
10327        resource=None,
10328    ):
10329        self.meta = meta if meta is not None else None
10330        '''
10331         Reserved for future use.
10332        '''
10333        self.rate_limit = rate_limit if rate_limit is not None else None
10334        '''
10335         Rate limit information.
10336        '''
10337        self.resource = resource if resource is not None else None
10338        '''
10339         The updated Resource.
10340        '''
10341
10342    def __repr__(self):
10343        return '<sdm.ResourceUpdateResponse ' + \
10344            'meta: ' + repr(self.meta) + ' ' +\
10345            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10346            'resource: ' + repr(self.resource) + ' ' +\
10347            '>'
10348
10349    def to_dict(self):
10350        return {
10351            'meta': self.meta,
10352            'rate_limit': self.rate_limit,
10353            'resource': self.resource,
10354        }
10355
10356    @classmethod
10357    def from_dict(cls, d):
10358        return cls(
10359            meta=d.get('meta'),
10360            rate_limit=d.get('rate_limit'),
10361            resource=d.get('resource'),
10362        )
10363
10364
10365class Role:
10366    '''
10367         A Role has a list of access rules which determine which Resources the members
10368     of the Role have access to. An Account can be a member of multiple Roles via
10369     AccountAttachments.
10370    '''
10371    __slots__ = [
10372        'access_rules',
10373        'id',
10374        'managed_by',
10375        'name',
10376        'tags',
10377    ]
10378
10379    def __init__(
10380        self,
10381        access_rules=None,
10382        id=None,
10383        managed_by=None,
10384        name=None,
10385        tags=None,
10386    ):
10387        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10388        )
10389        '''
10390         AccessRules is a list of access rules defining the resources this Role has access to.
10391        '''
10392        self.id = id if id is not None else ''
10393        '''
10394         Unique identifier of the Role.
10395        '''
10396        self.managed_by = managed_by if managed_by is not None else ''
10397        '''
10398         Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.
10399        '''
10400        self.name = name if name is not None else ''
10401        '''
10402         Unique human-readable name of the Role.
10403        '''
10404        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10405        '''
10406         Tags is a map of key, value pairs.
10407        '''
10408
10409    def __repr__(self):
10410        return '<sdm.Role ' + \
10411            'access_rules: ' + repr(self.access_rules) + ' ' +\
10412            'id: ' + repr(self.id) + ' ' +\
10413            'managed_by: ' + repr(self.managed_by) + ' ' +\
10414            'name: ' + repr(self.name) + ' ' +\
10415            'tags: ' + repr(self.tags) + ' ' +\
10416            '>'
10417
10418    def to_dict(self):
10419        return {
10420            'access_rules': self.access_rules,
10421            'id': self.id,
10422            'managed_by': self.managed_by,
10423            'name': self.name,
10424            'tags': self.tags,
10425        }
10426
10427    @classmethod
10428    def from_dict(cls, d):
10429        return cls(
10430            access_rules=d.get('access_rules'),
10431            id=d.get('id'),
10432            managed_by=d.get('managed_by'),
10433            name=d.get('name'),
10434            tags=d.get('tags'),
10435        )
10436
10437
10438class RoleCreateResponse:
10439    '''
10440         RoleCreateResponse reports how the Roles were created in the system. It can
10441     communicate partial successes or failures.
10442    '''
10443    __slots__ = [
10444        'meta',
10445        'rate_limit',
10446        'role',
10447    ]
10448
10449    def __init__(
10450        self,
10451        meta=None,
10452        rate_limit=None,
10453        role=None,
10454    ):
10455        self.meta = meta if meta is not None else None
10456        '''
10457         Reserved for future use.
10458        '''
10459        self.rate_limit = rate_limit if rate_limit is not None else None
10460        '''
10461         Rate limit information.
10462        '''
10463        self.role = role if role is not None else None
10464        '''
10465         The created Role.
10466        '''
10467
10468    def __repr__(self):
10469        return '<sdm.RoleCreateResponse ' + \
10470            'meta: ' + repr(self.meta) + ' ' +\
10471            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10472            'role: ' + repr(self.role) + ' ' +\
10473            '>'
10474
10475    def to_dict(self):
10476        return {
10477            'meta': self.meta,
10478            'rate_limit': self.rate_limit,
10479            'role': self.role,
10480        }
10481
10482    @classmethod
10483    def from_dict(cls, d):
10484        return cls(
10485            meta=d.get('meta'),
10486            rate_limit=d.get('rate_limit'),
10487            role=d.get('role'),
10488        )
10489
10490
10491class RoleDeleteResponse:
10492    '''
10493         RoleDeleteResponse returns information about a Role that was deleted.
10494    '''
10495    __slots__ = [
10496        'meta',
10497        'rate_limit',
10498    ]
10499
10500    def __init__(
10501        self,
10502        meta=None,
10503        rate_limit=None,
10504    ):
10505        self.meta = meta if meta is not None else None
10506        '''
10507         Reserved for future use.
10508        '''
10509        self.rate_limit = rate_limit if rate_limit is not None else None
10510        '''
10511         Rate limit information.
10512        '''
10513
10514    def __repr__(self):
10515        return '<sdm.RoleDeleteResponse ' + \
10516            'meta: ' + repr(self.meta) + ' ' +\
10517            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10518            '>'
10519
10520    def to_dict(self):
10521        return {
10522            'meta': self.meta,
10523            'rate_limit': self.rate_limit,
10524        }
10525
10526    @classmethod
10527    def from_dict(cls, d):
10528        return cls(
10529            meta=d.get('meta'),
10530            rate_limit=d.get('rate_limit'),
10531        )
10532
10533
10534class RoleGetResponse:
10535    '''
10536         RoleGetResponse returns a requested Role.
10537    '''
10538    __slots__ = [
10539        'meta',
10540        'rate_limit',
10541        'role',
10542    ]
10543
10544    def __init__(
10545        self,
10546        meta=None,
10547        rate_limit=None,
10548        role=None,
10549    ):
10550        self.meta = meta if meta is not None else None
10551        '''
10552         Reserved for future use.
10553        '''
10554        self.rate_limit = rate_limit if rate_limit is not None else None
10555        '''
10556         Rate limit information.
10557        '''
10558        self.role = role if role is not None else None
10559        '''
10560         The requested Role.
10561        '''
10562
10563    def __repr__(self):
10564        return '<sdm.RoleGetResponse ' + \
10565            'meta: ' + repr(self.meta) + ' ' +\
10566            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10567            'role: ' + repr(self.role) + ' ' +\
10568            '>'
10569
10570    def to_dict(self):
10571        return {
10572            'meta': self.meta,
10573            'rate_limit': self.rate_limit,
10574            'role': self.role,
10575        }
10576
10577    @classmethod
10578    def from_dict(cls, d):
10579        return cls(
10580            meta=d.get('meta'),
10581            rate_limit=d.get('rate_limit'),
10582            role=d.get('role'),
10583        )
10584
10585
10586class RoleUpdateResponse:
10587    '''
10588         RoleUpdateResponse returns the fields of a Role after it has been updated by
10589     a RoleUpdateRequest.
10590    '''
10591    __slots__ = [
10592        'meta',
10593        'rate_limit',
10594        'role',
10595    ]
10596
10597    def __init__(
10598        self,
10599        meta=None,
10600        rate_limit=None,
10601        role=None,
10602    ):
10603        self.meta = meta if meta is not None else None
10604        '''
10605         Reserved for future use.
10606        '''
10607        self.rate_limit = rate_limit if rate_limit is not None else None
10608        '''
10609         Rate limit information.
10610        '''
10611        self.role = role if role is not None else None
10612        '''
10613         The updated Role.
10614        '''
10615
10616    def __repr__(self):
10617        return '<sdm.RoleUpdateResponse ' + \
10618            'meta: ' + repr(self.meta) + ' ' +\
10619            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10620            'role: ' + repr(self.role) + ' ' +\
10621            '>'
10622
10623    def to_dict(self):
10624        return {
10625            'meta': self.meta,
10626            'rate_limit': self.rate_limit,
10627            'role': self.role,
10628        }
10629
10630    @classmethod
10631    def from_dict(cls, d):
10632        return cls(
10633            meta=d.get('meta'),
10634            rate_limit=d.get('rate_limit'),
10635            role=d.get('role'),
10636        )
10637
10638
10639class SQLServer:
10640    __slots__ = [
10641        'bind_interface',
10642        'database',
10643        'egress_filter',
10644        'healthy',
10645        'hostname',
10646        'id',
10647        'name',
10648        'override_database',
10649        'password',
10650        'port',
10651        'port_override',
10652        'schema',
10653        'secret_store_id',
10654        'tags',
10655        'username',
10656    ]
10657
10658    def __init__(
10659        self,
10660        bind_interface=None,
10661        database=None,
10662        egress_filter=None,
10663        healthy=None,
10664        hostname=None,
10665        id=None,
10666        name=None,
10667        override_database=None,
10668        password=None,
10669        port=None,
10670        port_override=None,
10671        schema=None,
10672        secret_store_id=None,
10673        tags=None,
10674        username=None,
10675    ):
10676        self.bind_interface = bind_interface if bind_interface is not None else ''
10677        '''
10678         Bind interface
10679        '''
10680        self.database = database if database is not None else ''
10681        self.egress_filter = egress_filter if egress_filter is not None else ''
10682        '''
10683         A filter applied to the routing logic to pin datasource to nodes.
10684        '''
10685        self.healthy = healthy if healthy is not None else False
10686        '''
10687         True if the datasource is reachable and the credentials are valid.
10688        '''
10689        self.hostname = hostname if hostname is not None else ''
10690        self.id = id if id is not None else ''
10691        '''
10692         Unique identifier of the Resource.
10693        '''
10694        self.name = name if name is not None else ''
10695        '''
10696         Unique human-readable name of the Resource.
10697        '''
10698        self.override_database = override_database if override_database is not None else False
10699        self.password = password if password is not None else ''
10700        self.port = port if port is not None else 0
10701        self.port_override = port_override if port_override is not None else 0
10702        self.schema = schema if schema is not None else ''
10703        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10704        '''
10705         ID of the secret store containing credentials for this resource, if any.
10706        '''
10707        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10708        '''
10709         Tags is a map of key, value pairs.
10710        '''
10711        self.username = username if username is not None else ''
10712
10713    def __repr__(self):
10714        return '<sdm.SQLServer ' + \
10715            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10716            'database: ' + repr(self.database) + ' ' +\
10717            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10718            'healthy: ' + repr(self.healthy) + ' ' +\
10719            'hostname: ' + repr(self.hostname) + ' ' +\
10720            'id: ' + repr(self.id) + ' ' +\
10721            'name: ' + repr(self.name) + ' ' +\
10722            'override_database: ' + repr(self.override_database) + ' ' +\
10723            'password: ' + repr(self.password) + ' ' +\
10724            'port: ' + repr(self.port) + ' ' +\
10725            'port_override: ' + repr(self.port_override) + ' ' +\
10726            'schema: ' + repr(self.schema) + ' ' +\
10727            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10728            'tags: ' + repr(self.tags) + ' ' +\
10729            'username: ' + repr(self.username) + ' ' +\
10730            '>'
10731
10732    def to_dict(self):
10733        return {
10734            'bind_interface': self.bind_interface,
10735            'database': self.database,
10736            'egress_filter': self.egress_filter,
10737            'healthy': self.healthy,
10738            'hostname': self.hostname,
10739            'id': self.id,
10740            'name': self.name,
10741            'override_database': self.override_database,
10742            'password': self.password,
10743            'port': self.port,
10744            'port_override': self.port_override,
10745            'schema': self.schema,
10746            'secret_store_id': self.secret_store_id,
10747            'tags': self.tags,
10748            'username': self.username,
10749        }
10750
10751    @classmethod
10752    def from_dict(cls, d):
10753        return cls(
10754            bind_interface=d.get('bind_interface'),
10755            database=d.get('database'),
10756            egress_filter=d.get('egress_filter'),
10757            healthy=d.get('healthy'),
10758            hostname=d.get('hostname'),
10759            id=d.get('id'),
10760            name=d.get('name'),
10761            override_database=d.get('override_database'),
10762            password=d.get('password'),
10763            port=d.get('port'),
10764            port_override=d.get('port_override'),
10765            schema=d.get('schema'),
10766            secret_store_id=d.get('secret_store_id'),
10767            tags=d.get('tags'),
10768            username=d.get('username'),
10769        )
10770
10771
10772class SSH:
10773    __slots__ = [
10774        'allow_deprecated_key_exchanges',
10775        'bind_interface',
10776        'egress_filter',
10777        'healthy',
10778        'hostname',
10779        'id',
10780        'key_type',
10781        'name',
10782        'port',
10783        'port_forwarding',
10784        'port_override',
10785        'public_key',
10786        'secret_store_id',
10787        'tags',
10788        'username',
10789    ]
10790
10791    def __init__(
10792        self,
10793        allow_deprecated_key_exchanges=None,
10794        bind_interface=None,
10795        egress_filter=None,
10796        healthy=None,
10797        hostname=None,
10798        id=None,
10799        key_type=None,
10800        name=None,
10801        port=None,
10802        port_forwarding=None,
10803        port_override=None,
10804        public_key=None,
10805        secret_store_id=None,
10806        tags=None,
10807        username=None,
10808    ):
10809        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10810        self.bind_interface = bind_interface if bind_interface is not None else ''
10811        '''
10812         Bind interface
10813        '''
10814        self.egress_filter = egress_filter if egress_filter is not None else ''
10815        '''
10816         A filter applied to the routing logic to pin datasource to nodes.
10817        '''
10818        self.healthy = healthy if healthy is not None else False
10819        '''
10820         True if the datasource is reachable and the credentials are valid.
10821        '''
10822        self.hostname = hostname if hostname is not None else ''
10823        self.id = id if id is not None else ''
10824        '''
10825         Unique identifier of the Resource.
10826        '''
10827        self.key_type = key_type if key_type is not None else ''
10828        self.name = name if name is not None else ''
10829        '''
10830         Unique human-readable name of the Resource.
10831        '''
10832        self.port = port if port is not None else 0
10833        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10834        self.port_override = port_override if port_override is not None else 0
10835        self.public_key = public_key if public_key is not None else ''
10836        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10837        '''
10838         ID of the secret store containing credentials for this resource, if any.
10839        '''
10840        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10841        '''
10842         Tags is a map of key, value pairs.
10843        '''
10844        self.username = username if username is not None else ''
10845
10846    def __repr__(self):
10847        return '<sdm.SSH ' + \
10848            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10849            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10850            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10851            'healthy: ' + repr(self.healthy) + ' ' +\
10852            'hostname: ' + repr(self.hostname) + ' ' +\
10853            'id: ' + repr(self.id) + ' ' +\
10854            'key_type: ' + repr(self.key_type) + ' ' +\
10855            'name: ' + repr(self.name) + ' ' +\
10856            'port: ' + repr(self.port) + ' ' +\
10857            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10858            'port_override: ' + repr(self.port_override) + ' ' +\
10859            'public_key: ' + repr(self.public_key) + ' ' +\
10860            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10861            'tags: ' + repr(self.tags) + ' ' +\
10862            'username: ' + repr(self.username) + ' ' +\
10863            '>'
10864
10865    def to_dict(self):
10866        return {
10867            'allow_deprecated_key_exchanges':
10868            self.allow_deprecated_key_exchanges,
10869            'bind_interface': self.bind_interface,
10870            'egress_filter': self.egress_filter,
10871            'healthy': self.healthy,
10872            'hostname': self.hostname,
10873            'id': self.id,
10874            'key_type': self.key_type,
10875            'name': self.name,
10876            'port': self.port,
10877            'port_forwarding': self.port_forwarding,
10878            'port_override': self.port_override,
10879            'public_key': self.public_key,
10880            'secret_store_id': self.secret_store_id,
10881            'tags': self.tags,
10882            'username': self.username,
10883        }
10884
10885    @classmethod
10886    def from_dict(cls, d):
10887        return cls(
10888            allow_deprecated_key_exchanges=d.get(
10889                'allow_deprecated_key_exchanges'),
10890            bind_interface=d.get('bind_interface'),
10891            egress_filter=d.get('egress_filter'),
10892            healthy=d.get('healthy'),
10893            hostname=d.get('hostname'),
10894            id=d.get('id'),
10895            key_type=d.get('key_type'),
10896            name=d.get('name'),
10897            port=d.get('port'),
10898            port_forwarding=d.get('port_forwarding'),
10899            port_override=d.get('port_override'),
10900            public_key=d.get('public_key'),
10901            secret_store_id=d.get('secret_store_id'),
10902            tags=d.get('tags'),
10903            username=d.get('username'),
10904        )
10905
10906
10907class SSHCert:
10908    __slots__ = [
10909        'allow_deprecated_key_exchanges',
10910        'bind_interface',
10911        'egress_filter',
10912        'healthy',
10913        'hostname',
10914        'id',
10915        'key_type',
10916        'name',
10917        'port',
10918        'port_forwarding',
10919        'port_override',
10920        'remote_identity_group_id',
10921        'remote_identity_healthcheck_username',
10922        'secret_store_id',
10923        'tags',
10924        'username',
10925    ]
10926
10927    def __init__(
10928        self,
10929        allow_deprecated_key_exchanges=None,
10930        bind_interface=None,
10931        egress_filter=None,
10932        healthy=None,
10933        hostname=None,
10934        id=None,
10935        key_type=None,
10936        name=None,
10937        port=None,
10938        port_forwarding=None,
10939        port_override=None,
10940        remote_identity_group_id=None,
10941        remote_identity_healthcheck_username=None,
10942        secret_store_id=None,
10943        tags=None,
10944        username=None,
10945    ):
10946        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10947        self.bind_interface = bind_interface if bind_interface is not None else ''
10948        '''
10949         Bind interface
10950        '''
10951        self.egress_filter = egress_filter if egress_filter is not None else ''
10952        '''
10953         A filter applied to the routing logic to pin datasource to nodes.
10954        '''
10955        self.healthy = healthy if healthy is not None else False
10956        '''
10957         True if the datasource is reachable and the credentials are valid.
10958        '''
10959        self.hostname = hostname if hostname is not None else ''
10960        self.id = id if id is not None else ''
10961        '''
10962         Unique identifier of the Resource.
10963        '''
10964        self.key_type = key_type if key_type is not None else ''
10965        self.name = name if name is not None else ''
10966        '''
10967         Unique human-readable name of the Resource.
10968        '''
10969        self.port = port if port is not None else 0
10970        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10971        self.port_override = port_override if port_override is not None else 0
10972        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10973        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10974        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10975        '''
10976         ID of the secret store containing credentials for this resource, if any.
10977        '''
10978        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10979        '''
10980         Tags is a map of key, value pairs.
10981        '''
10982        self.username = username if username is not None else ''
10983
10984    def __repr__(self):
10985        return '<sdm.SSHCert ' + \
10986            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10987            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10988            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10989            'healthy: ' + repr(self.healthy) + ' ' +\
10990            'hostname: ' + repr(self.hostname) + ' ' +\
10991            'id: ' + repr(self.id) + ' ' +\
10992            'key_type: ' + repr(self.key_type) + ' ' +\
10993            'name: ' + repr(self.name) + ' ' +\
10994            'port: ' + repr(self.port) + ' ' +\
10995            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10996            'port_override: ' + repr(self.port_override) + ' ' +\
10997            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10998            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
10999            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11000            'tags: ' + repr(self.tags) + ' ' +\
11001            'username: ' + repr(self.username) + ' ' +\
11002            '>'
11003
11004    def to_dict(self):
11005        return {
11006            'allow_deprecated_key_exchanges':
11007            self.allow_deprecated_key_exchanges,
11008            'bind_interface': self.bind_interface,
11009            'egress_filter': self.egress_filter,
11010            'healthy': self.healthy,
11011            'hostname': self.hostname,
11012            'id': self.id,
11013            'key_type': self.key_type,
11014            'name': self.name,
11015            'port': self.port,
11016            'port_forwarding': self.port_forwarding,
11017            'port_override': self.port_override,
11018            'remote_identity_group_id': self.remote_identity_group_id,
11019            'remote_identity_healthcheck_username':
11020            self.remote_identity_healthcheck_username,
11021            'secret_store_id': self.secret_store_id,
11022            'tags': self.tags,
11023            'username': self.username,
11024        }
11025
11026    @classmethod
11027    def from_dict(cls, d):
11028        return cls(
11029            allow_deprecated_key_exchanges=d.get(
11030                'allow_deprecated_key_exchanges'),
11031            bind_interface=d.get('bind_interface'),
11032            egress_filter=d.get('egress_filter'),
11033            healthy=d.get('healthy'),
11034            hostname=d.get('hostname'),
11035            id=d.get('id'),
11036            key_type=d.get('key_type'),
11037            name=d.get('name'),
11038            port=d.get('port'),
11039            port_forwarding=d.get('port_forwarding'),
11040            port_override=d.get('port_override'),
11041            remote_identity_group_id=d.get('remote_identity_group_id'),
11042            remote_identity_healthcheck_username=d.get(
11043                'remote_identity_healthcheck_username'),
11044            secret_store_id=d.get('secret_store_id'),
11045            tags=d.get('tags'),
11046            username=d.get('username'),
11047        )
11048
11049
11050class SSHCustomerKey:
11051    __slots__ = [
11052        'allow_deprecated_key_exchanges',
11053        'bind_interface',
11054        'egress_filter',
11055        'healthy',
11056        'hostname',
11057        'id',
11058        'name',
11059        'port',
11060        'port_forwarding',
11061        'port_override',
11062        'private_key',
11063        'secret_store_id',
11064        'tags',
11065        'username',
11066    ]
11067
11068    def __init__(
11069        self,
11070        allow_deprecated_key_exchanges=None,
11071        bind_interface=None,
11072        egress_filter=None,
11073        healthy=None,
11074        hostname=None,
11075        id=None,
11076        name=None,
11077        port=None,
11078        port_forwarding=None,
11079        port_override=None,
11080        private_key=None,
11081        secret_store_id=None,
11082        tags=None,
11083        username=None,
11084    ):
11085        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11086        self.bind_interface = bind_interface if bind_interface is not None else ''
11087        '''
11088         Bind interface
11089        '''
11090        self.egress_filter = egress_filter if egress_filter is not None else ''
11091        '''
11092         A filter applied to the routing logic to pin datasource to nodes.
11093        '''
11094        self.healthy = healthy if healthy is not None else False
11095        '''
11096         True if the datasource is reachable and the credentials are valid.
11097        '''
11098        self.hostname = hostname if hostname is not None else ''
11099        self.id = id if id is not None else ''
11100        '''
11101         Unique identifier of the Resource.
11102        '''
11103        self.name = name if name is not None else ''
11104        '''
11105         Unique human-readable name of the Resource.
11106        '''
11107        self.port = port if port is not None else 0
11108        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11109        self.port_override = port_override if port_override is not None else 0
11110        self.private_key = private_key if private_key is not None else ''
11111        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11112        '''
11113         ID of the secret store containing credentials for this resource, if any.
11114        '''
11115        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11116        '''
11117         Tags is a map of key, value pairs.
11118        '''
11119        self.username = username if username is not None else ''
11120
11121    def __repr__(self):
11122        return '<sdm.SSHCustomerKey ' + \
11123            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11124            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11125            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11126            'healthy: ' + repr(self.healthy) + ' ' +\
11127            'hostname: ' + repr(self.hostname) + ' ' +\
11128            'id: ' + repr(self.id) + ' ' +\
11129            'name: ' + repr(self.name) + ' ' +\
11130            'port: ' + repr(self.port) + ' ' +\
11131            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11132            'port_override: ' + repr(self.port_override) + ' ' +\
11133            'private_key: ' + repr(self.private_key) + ' ' +\
11134            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11135            'tags: ' + repr(self.tags) + ' ' +\
11136            'username: ' + repr(self.username) + ' ' +\
11137            '>'
11138
11139    def to_dict(self):
11140        return {
11141            'allow_deprecated_key_exchanges':
11142            self.allow_deprecated_key_exchanges,
11143            'bind_interface': self.bind_interface,
11144            'egress_filter': self.egress_filter,
11145            'healthy': self.healthy,
11146            'hostname': self.hostname,
11147            'id': self.id,
11148            'name': self.name,
11149            'port': self.port,
11150            'port_forwarding': self.port_forwarding,
11151            'port_override': self.port_override,
11152            'private_key': self.private_key,
11153            'secret_store_id': self.secret_store_id,
11154            'tags': self.tags,
11155            'username': self.username,
11156        }
11157
11158    @classmethod
11159    def from_dict(cls, d):
11160        return cls(
11161            allow_deprecated_key_exchanges=d.get(
11162                'allow_deprecated_key_exchanges'),
11163            bind_interface=d.get('bind_interface'),
11164            egress_filter=d.get('egress_filter'),
11165            healthy=d.get('healthy'),
11166            hostname=d.get('hostname'),
11167            id=d.get('id'),
11168            name=d.get('name'),
11169            port=d.get('port'),
11170            port_forwarding=d.get('port_forwarding'),
11171            port_override=d.get('port_override'),
11172            private_key=d.get('private_key'),
11173            secret_store_id=d.get('secret_store_id'),
11174            tags=d.get('tags'),
11175            username=d.get('username'),
11176        )
11177
11178
11179class SecretStoreCreateResponse:
11180    '''
11181         SecretStoreCreateResponse reports how the SecretStores were created in the system.
11182    '''
11183    __slots__ = [
11184        'meta',
11185        'rate_limit',
11186        'secret_store',
11187    ]
11188
11189    def __init__(
11190        self,
11191        meta=None,
11192        rate_limit=None,
11193        secret_store=None,
11194    ):
11195        self.meta = meta if meta is not None else None
11196        '''
11197         Reserved for future use.
11198        '''
11199        self.rate_limit = rate_limit if rate_limit is not None else None
11200        '''
11201         Rate limit information.
11202        '''
11203        self.secret_store = secret_store if secret_store is not None else None
11204        '''
11205         The created SecretStore.
11206        '''
11207
11208    def __repr__(self):
11209        return '<sdm.SecretStoreCreateResponse ' + \
11210            'meta: ' + repr(self.meta) + ' ' +\
11211            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11212            'secret_store: ' + repr(self.secret_store) + ' ' +\
11213            '>'
11214
11215    def to_dict(self):
11216        return {
11217            'meta': self.meta,
11218            'rate_limit': self.rate_limit,
11219            'secret_store': self.secret_store,
11220        }
11221
11222    @classmethod
11223    def from_dict(cls, d):
11224        return cls(
11225            meta=d.get('meta'),
11226            rate_limit=d.get('rate_limit'),
11227            secret_store=d.get('secret_store'),
11228        )
11229
11230
11231class SecretStoreDeleteResponse:
11232    '''
11233         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11234    '''
11235    __slots__ = [
11236        'meta',
11237        'rate_limit',
11238    ]
11239
11240    def __init__(
11241        self,
11242        meta=None,
11243        rate_limit=None,
11244    ):
11245        self.meta = meta if meta is not None else None
11246        '''
11247         Reserved for future use.
11248        '''
11249        self.rate_limit = rate_limit if rate_limit is not None else None
11250        '''
11251         Rate limit information.
11252        '''
11253
11254    def __repr__(self):
11255        return '<sdm.SecretStoreDeleteResponse ' + \
11256            'meta: ' + repr(self.meta) + ' ' +\
11257            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11258            '>'
11259
11260    def to_dict(self):
11261        return {
11262            'meta': self.meta,
11263            'rate_limit': self.rate_limit,
11264        }
11265
11266    @classmethod
11267    def from_dict(cls, d):
11268        return cls(
11269            meta=d.get('meta'),
11270            rate_limit=d.get('rate_limit'),
11271        )
11272
11273
11274class SecretStoreGetResponse:
11275    '''
11276         SecretStoreGetResponse returns a requested SecretStore.
11277    '''
11278    __slots__ = [
11279        'meta',
11280        'rate_limit',
11281        'secret_store',
11282    ]
11283
11284    def __init__(
11285        self,
11286        meta=None,
11287        rate_limit=None,
11288        secret_store=None,
11289    ):
11290        self.meta = meta if meta is not None else None
11291        '''
11292         Reserved for future use.
11293        '''
11294        self.rate_limit = rate_limit if rate_limit is not None else None
11295        '''
11296         Rate limit information.
11297        '''
11298        self.secret_store = secret_store if secret_store is not None else None
11299        '''
11300         The requested SecretStore.
11301        '''
11302
11303    def __repr__(self):
11304        return '<sdm.SecretStoreGetResponse ' + \
11305            'meta: ' + repr(self.meta) + ' ' +\
11306            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11307            'secret_store: ' + repr(self.secret_store) + ' ' +\
11308            '>'
11309
11310    def to_dict(self):
11311        return {
11312            'meta': self.meta,
11313            'rate_limit': self.rate_limit,
11314            'secret_store': self.secret_store,
11315        }
11316
11317    @classmethod
11318    def from_dict(cls, d):
11319        return cls(
11320            meta=d.get('meta'),
11321            rate_limit=d.get('rate_limit'),
11322            secret_store=d.get('secret_store'),
11323        )
11324
11325
11326class SecretStoreUpdateResponse:
11327    '''
11328         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11329     a SecretStoreUpdateRequest.
11330    '''
11331    __slots__ = [
11332        'meta',
11333        'rate_limit',
11334        'secret_store',
11335    ]
11336
11337    def __init__(
11338        self,
11339        meta=None,
11340        rate_limit=None,
11341        secret_store=None,
11342    ):
11343        self.meta = meta if meta is not None else None
11344        '''
11345         Reserved for future use.
11346        '''
11347        self.rate_limit = rate_limit if rate_limit is not None else None
11348        '''
11349         Rate limit information.
11350        '''
11351        self.secret_store = secret_store if secret_store is not None else None
11352        '''
11353         The updated SecretStore.
11354        '''
11355
11356    def __repr__(self):
11357        return '<sdm.SecretStoreUpdateResponse ' + \
11358            'meta: ' + repr(self.meta) + ' ' +\
11359            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11360            'secret_store: ' + repr(self.secret_store) + ' ' +\
11361            '>'
11362
11363    def to_dict(self):
11364        return {
11365            'meta': self.meta,
11366            'rate_limit': self.rate_limit,
11367            'secret_store': self.secret_store,
11368        }
11369
11370    @classmethod
11371    def from_dict(cls, d):
11372        return cls(
11373            meta=d.get('meta'),
11374            rate_limit=d.get('rate_limit'),
11375            secret_store=d.get('secret_store'),
11376        )
11377
11378
11379class Service:
11380    '''
11381         A Service is a service account that can connect to resources they are granted
11382     directly, or granted via roles. Services are typically automated jobs.
11383    '''
11384    __slots__ = [
11385        'id',
11386        'name',
11387        'suspended',
11388        'tags',
11389    ]
11390
11391    def __init__(
11392        self,
11393        id=None,
11394        name=None,
11395        suspended=None,
11396        tags=None,
11397    ):
11398        self.id = id if id is not None else ''
11399        '''
11400         Unique identifier of the Service.
11401        '''
11402        self.name = name if name is not None else ''
11403        '''
11404         Unique human-readable name of the Service.
11405        '''
11406        self.suspended = suspended if suspended is not None else False
11407        '''
11408         The Service's suspended state.
11409        '''
11410        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11411        '''
11412         Tags is a map of key, value pairs.
11413        '''
11414
11415    def __repr__(self):
11416        return '<sdm.Service ' + \
11417            'id: ' + repr(self.id) + ' ' +\
11418            'name: ' + repr(self.name) + ' ' +\
11419            'suspended: ' + repr(self.suspended) + ' ' +\
11420            'tags: ' + repr(self.tags) + ' ' +\
11421            '>'
11422
11423    def to_dict(self):
11424        return {
11425            'id': self.id,
11426            'name': self.name,
11427            'suspended': self.suspended,
11428            'tags': self.tags,
11429        }
11430
11431    @classmethod
11432    def from_dict(cls, d):
11433        return cls(
11434            id=d.get('id'),
11435            name=d.get('name'),
11436            suspended=d.get('suspended'),
11437            tags=d.get('tags'),
11438        )
11439
11440
11441class SingleStore:
11442    __slots__ = [
11443        'bind_interface',
11444        'database',
11445        'egress_filter',
11446        'healthy',
11447        'hostname',
11448        'id',
11449        'name',
11450        'password',
11451        'port',
11452        'port_override',
11453        'secret_store_id',
11454        'tags',
11455        'username',
11456    ]
11457
11458    def __init__(
11459        self,
11460        bind_interface=None,
11461        database=None,
11462        egress_filter=None,
11463        healthy=None,
11464        hostname=None,
11465        id=None,
11466        name=None,
11467        password=None,
11468        port=None,
11469        port_override=None,
11470        secret_store_id=None,
11471        tags=None,
11472        username=None,
11473    ):
11474        self.bind_interface = bind_interface if bind_interface is not None else ''
11475        '''
11476         Bind interface
11477        '''
11478        self.database = database if database is not None else ''
11479        self.egress_filter = egress_filter if egress_filter is not None else ''
11480        '''
11481         A filter applied to the routing logic to pin datasource to nodes.
11482        '''
11483        self.healthy = healthy if healthy is not None else False
11484        '''
11485         True if the datasource is reachable and the credentials are valid.
11486        '''
11487        self.hostname = hostname if hostname is not None else ''
11488        self.id = id if id is not None else ''
11489        '''
11490         Unique identifier of the Resource.
11491        '''
11492        self.name = name if name is not None else ''
11493        '''
11494         Unique human-readable name of the Resource.
11495        '''
11496        self.password = password if password is not None else ''
11497        self.port = port if port is not None else 0
11498        self.port_override = port_override if port_override is not None else 0
11499        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11500        '''
11501         ID of the secret store containing credentials for this resource, if any.
11502        '''
11503        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11504        '''
11505         Tags is a map of key, value pairs.
11506        '''
11507        self.username = username if username is not None else ''
11508
11509    def __repr__(self):
11510        return '<sdm.SingleStore ' + \
11511            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11512            'database: ' + repr(self.database) + ' ' +\
11513            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11514            'healthy: ' + repr(self.healthy) + ' ' +\
11515            'hostname: ' + repr(self.hostname) + ' ' +\
11516            'id: ' + repr(self.id) + ' ' +\
11517            'name: ' + repr(self.name) + ' ' +\
11518            'password: ' + repr(self.password) + ' ' +\
11519            'port: ' + repr(self.port) + ' ' +\
11520            'port_override: ' + repr(self.port_override) + ' ' +\
11521            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11522            'tags: ' + repr(self.tags) + ' ' +\
11523            'username: ' + repr(self.username) + ' ' +\
11524            '>'
11525
11526    def to_dict(self):
11527        return {
11528            'bind_interface': self.bind_interface,
11529            'database': self.database,
11530            'egress_filter': self.egress_filter,
11531            'healthy': self.healthy,
11532            'hostname': self.hostname,
11533            'id': self.id,
11534            'name': self.name,
11535            'password': self.password,
11536            'port': self.port,
11537            'port_override': self.port_override,
11538            'secret_store_id': self.secret_store_id,
11539            'tags': self.tags,
11540            'username': self.username,
11541        }
11542
11543    @classmethod
11544    def from_dict(cls, d):
11545        return cls(
11546            bind_interface=d.get('bind_interface'),
11547            database=d.get('database'),
11548            egress_filter=d.get('egress_filter'),
11549            healthy=d.get('healthy'),
11550            hostname=d.get('hostname'),
11551            id=d.get('id'),
11552            name=d.get('name'),
11553            password=d.get('password'),
11554            port=d.get('port'),
11555            port_override=d.get('port_override'),
11556            secret_store_id=d.get('secret_store_id'),
11557            tags=d.get('tags'),
11558            username=d.get('username'),
11559        )
11560
11561
11562class Snowflake:
11563    __slots__ = [
11564        'bind_interface',
11565        'database',
11566        'egress_filter',
11567        'healthy',
11568        'hostname',
11569        'id',
11570        'name',
11571        'password',
11572        'port_override',
11573        'schema',
11574        'secret_store_id',
11575        'tags',
11576        'username',
11577    ]
11578
11579    def __init__(
11580        self,
11581        bind_interface=None,
11582        database=None,
11583        egress_filter=None,
11584        healthy=None,
11585        hostname=None,
11586        id=None,
11587        name=None,
11588        password=None,
11589        port_override=None,
11590        schema=None,
11591        secret_store_id=None,
11592        tags=None,
11593        username=None,
11594    ):
11595        self.bind_interface = bind_interface if bind_interface is not None else ''
11596        '''
11597         Bind interface
11598        '''
11599        self.database = database if database is not None else ''
11600        self.egress_filter = egress_filter if egress_filter is not None else ''
11601        '''
11602         A filter applied to the routing logic to pin datasource to nodes.
11603        '''
11604        self.healthy = healthy if healthy is not None else False
11605        '''
11606         True if the datasource is reachable and the credentials are valid.
11607        '''
11608        self.hostname = hostname if hostname is not None else ''
11609        self.id = id if id is not None else ''
11610        '''
11611         Unique identifier of the Resource.
11612        '''
11613        self.name = name if name is not None else ''
11614        '''
11615         Unique human-readable name of the Resource.
11616        '''
11617        self.password = password if password is not None else ''
11618        self.port_override = port_override if port_override is not None else 0
11619        self.schema = schema if schema is not None else ''
11620        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11621        '''
11622         ID of the secret store containing credentials for this resource, if any.
11623        '''
11624        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11625        '''
11626         Tags is a map of key, value pairs.
11627        '''
11628        self.username = username if username is not None else ''
11629
11630    def __repr__(self):
11631        return '<sdm.Snowflake ' + \
11632            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11633            'database: ' + repr(self.database) + ' ' +\
11634            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11635            'healthy: ' + repr(self.healthy) + ' ' +\
11636            'hostname: ' + repr(self.hostname) + ' ' +\
11637            'id: ' + repr(self.id) + ' ' +\
11638            'name: ' + repr(self.name) + ' ' +\
11639            'password: ' + repr(self.password) + ' ' +\
11640            'port_override: ' + repr(self.port_override) + ' ' +\
11641            'schema: ' + repr(self.schema) + ' ' +\
11642            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11643            'tags: ' + repr(self.tags) + ' ' +\
11644            'username: ' + repr(self.username) + ' ' +\
11645            '>'
11646
11647    def to_dict(self):
11648        return {
11649            'bind_interface': self.bind_interface,
11650            'database': self.database,
11651            'egress_filter': self.egress_filter,
11652            'healthy': self.healthy,
11653            'hostname': self.hostname,
11654            'id': self.id,
11655            'name': self.name,
11656            'password': self.password,
11657            'port_override': self.port_override,
11658            'schema': self.schema,
11659            'secret_store_id': self.secret_store_id,
11660            'tags': self.tags,
11661            'username': self.username,
11662        }
11663
11664    @classmethod
11665    def from_dict(cls, d):
11666        return cls(
11667            bind_interface=d.get('bind_interface'),
11668            database=d.get('database'),
11669            egress_filter=d.get('egress_filter'),
11670            healthy=d.get('healthy'),
11671            hostname=d.get('hostname'),
11672            id=d.get('id'),
11673            name=d.get('name'),
11674            password=d.get('password'),
11675            port_override=d.get('port_override'),
11676            schema=d.get('schema'),
11677            secret_store_id=d.get('secret_store_id'),
11678            tags=d.get('tags'),
11679            username=d.get('username'),
11680        )
11681
11682
11683class Snowsight:
11684    '''
11685    Snowsight is currently unstable, and its API may change, or it may be removed,
11686    without a major version bump.
11687    '''
11688    __slots__ = [
11689        'bind_interface',
11690        'egress_filter',
11691        'healthcheck_username',
11692        'healthy',
11693        'id',
11694        'name',
11695        'port_override',
11696        'samlmetadata',
11697        'secret_store_id',
11698        'subdomain',
11699        'tags',
11700    ]
11701
11702    def __init__(
11703        self,
11704        bind_interface=None,
11705        egress_filter=None,
11706        healthcheck_username=None,
11707        healthy=None,
11708        id=None,
11709        name=None,
11710        port_override=None,
11711        samlmetadata=None,
11712        secret_store_id=None,
11713        subdomain=None,
11714        tags=None,
11715    ):
11716        self.bind_interface = bind_interface if bind_interface is not None else ''
11717        '''
11718         Bind interface
11719        '''
11720        self.egress_filter = egress_filter if egress_filter is not None else ''
11721        '''
11722         A filter applied to the routing logic to pin datasource to nodes.
11723        '''
11724        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11725        self.healthy = healthy if healthy is not None else False
11726        '''
11727         True if the datasource is reachable and the credentials are valid.
11728        '''
11729        self.id = id if id is not None else ''
11730        '''
11731         Unique identifier of the Resource.
11732        '''
11733        self.name = name if name is not None else ''
11734        '''
11735         Unique human-readable name of the Resource.
11736        '''
11737        self.port_override = port_override if port_override is not None else 0
11738        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11739        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11740        '''
11741         ID of the secret store containing credentials for this resource, if any.
11742        '''
11743        self.subdomain = subdomain if subdomain is not None else ''
11744        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11745        '''
11746         Tags is a map of key, value pairs.
11747        '''
11748
11749    def __repr__(self):
11750        return '<sdm.Snowsight ' + \
11751            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11752            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11753            'healthcheck_username: ' + repr(self.healthcheck_username) + ' ' +\
11754            'healthy: ' + repr(self.healthy) + ' ' +\
11755            'id: ' + repr(self.id) + ' ' +\
11756            'name: ' + repr(self.name) + ' ' +\
11757            'port_override: ' + repr(self.port_override) + ' ' +\
11758            'samlmetadata: ' + repr(self.samlmetadata) + ' ' +\
11759            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11760            'subdomain: ' + repr(self.subdomain) + ' ' +\
11761            'tags: ' + repr(self.tags) + ' ' +\
11762            '>'
11763
11764    def to_dict(self):
11765        return {
11766            'bind_interface': self.bind_interface,
11767            'egress_filter': self.egress_filter,
11768            'healthcheck_username': self.healthcheck_username,
11769            'healthy': self.healthy,
11770            'id': self.id,
11771            'name': self.name,
11772            'port_override': self.port_override,
11773            'samlmetadata': self.samlmetadata,
11774            'secret_store_id': self.secret_store_id,
11775            'subdomain': self.subdomain,
11776            'tags': self.tags,
11777        }
11778
11779    @classmethod
11780    def from_dict(cls, d):
11781        return cls(
11782            bind_interface=d.get('bind_interface'),
11783            egress_filter=d.get('egress_filter'),
11784            healthcheck_username=d.get('healthcheck_username'),
11785            healthy=d.get('healthy'),
11786            id=d.get('id'),
11787            name=d.get('name'),
11788            port_override=d.get('port_override'),
11789            samlmetadata=d.get('samlmetadata'),
11790            secret_store_id=d.get('secret_store_id'),
11791            subdomain=d.get('subdomain'),
11792            tags=d.get('tags'),
11793        )
11794
11795
11796class Sybase:
11797    __slots__ = [
11798        'bind_interface',
11799        'egress_filter',
11800        'healthy',
11801        'hostname',
11802        'id',
11803        'name',
11804        'password',
11805        'port',
11806        'port_override',
11807        'secret_store_id',
11808        'tags',
11809        'username',
11810    ]
11811
11812    def __init__(
11813        self,
11814        bind_interface=None,
11815        egress_filter=None,
11816        healthy=None,
11817        hostname=None,
11818        id=None,
11819        name=None,
11820        password=None,
11821        port=None,
11822        port_override=None,
11823        secret_store_id=None,
11824        tags=None,
11825        username=None,
11826    ):
11827        self.bind_interface = bind_interface if bind_interface is not None else ''
11828        '''
11829         Bind interface
11830        '''
11831        self.egress_filter = egress_filter if egress_filter is not None else ''
11832        '''
11833         A filter applied to the routing logic to pin datasource to nodes.
11834        '''
11835        self.healthy = healthy if healthy is not None else False
11836        '''
11837         True if the datasource is reachable and the credentials are valid.
11838        '''
11839        self.hostname = hostname if hostname is not None else ''
11840        self.id = id if id is not None else ''
11841        '''
11842         Unique identifier of the Resource.
11843        '''
11844        self.name = name if name is not None else ''
11845        '''
11846         Unique human-readable name of the Resource.
11847        '''
11848        self.password = password if password is not None else ''
11849        self.port = port if port is not None else 0
11850        self.port_override = port_override if port_override is not None else 0
11851        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11852        '''
11853         ID of the secret store containing credentials for this resource, if any.
11854        '''
11855        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11856        '''
11857         Tags is a map of key, value pairs.
11858        '''
11859        self.username = username if username is not None else ''
11860
11861    def __repr__(self):
11862        return '<sdm.Sybase ' + \
11863            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11864            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11865            'healthy: ' + repr(self.healthy) + ' ' +\
11866            'hostname: ' + repr(self.hostname) + ' ' +\
11867            'id: ' + repr(self.id) + ' ' +\
11868            'name: ' + repr(self.name) + ' ' +\
11869            'password: ' + repr(self.password) + ' ' +\
11870            'port: ' + repr(self.port) + ' ' +\
11871            'port_override: ' + repr(self.port_override) + ' ' +\
11872            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11873            'tags: ' + repr(self.tags) + ' ' +\
11874            'username: ' + repr(self.username) + ' ' +\
11875            '>'
11876
11877    def to_dict(self):
11878        return {
11879            'bind_interface': self.bind_interface,
11880            'egress_filter': self.egress_filter,
11881            'healthy': self.healthy,
11882            'hostname': self.hostname,
11883            'id': self.id,
11884            'name': self.name,
11885            'password': self.password,
11886            'port': self.port,
11887            'port_override': self.port_override,
11888            'secret_store_id': self.secret_store_id,
11889            'tags': self.tags,
11890            'username': self.username,
11891        }
11892
11893    @classmethod
11894    def from_dict(cls, d):
11895        return cls(
11896            bind_interface=d.get('bind_interface'),
11897            egress_filter=d.get('egress_filter'),
11898            healthy=d.get('healthy'),
11899            hostname=d.get('hostname'),
11900            id=d.get('id'),
11901            name=d.get('name'),
11902            password=d.get('password'),
11903            port=d.get('port'),
11904            port_override=d.get('port_override'),
11905            secret_store_id=d.get('secret_store_id'),
11906            tags=d.get('tags'),
11907            username=d.get('username'),
11908        )
11909
11910
11911class SybaseIQ:
11912    __slots__ = [
11913        'bind_interface',
11914        'egress_filter',
11915        'healthy',
11916        'hostname',
11917        'id',
11918        'name',
11919        'password',
11920        'port',
11921        'port_override',
11922        'secret_store_id',
11923        'tags',
11924        'username',
11925    ]
11926
11927    def __init__(
11928        self,
11929        bind_interface=None,
11930        egress_filter=None,
11931        healthy=None,
11932        hostname=None,
11933        id=None,
11934        name=None,
11935        password=None,
11936        port=None,
11937        port_override=None,
11938        secret_store_id=None,
11939        tags=None,
11940        username=None,
11941    ):
11942        self.bind_interface = bind_interface if bind_interface is not None else ''
11943        '''
11944         Bind interface
11945        '''
11946        self.egress_filter = egress_filter if egress_filter is not None else ''
11947        '''
11948         A filter applied to the routing logic to pin datasource to nodes.
11949        '''
11950        self.healthy = healthy if healthy is not None else False
11951        '''
11952         True if the datasource is reachable and the credentials are valid.
11953        '''
11954        self.hostname = hostname if hostname is not None else ''
11955        self.id = id if id is not None else ''
11956        '''
11957         Unique identifier of the Resource.
11958        '''
11959        self.name = name if name is not None else ''
11960        '''
11961         Unique human-readable name of the Resource.
11962        '''
11963        self.password = password if password is not None else ''
11964        self.port = port if port is not None else 0
11965        self.port_override = port_override if port_override is not None else 0
11966        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11967        '''
11968         ID of the secret store containing credentials for this resource, if any.
11969        '''
11970        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11971        '''
11972         Tags is a map of key, value pairs.
11973        '''
11974        self.username = username if username is not None else ''
11975
11976    def __repr__(self):
11977        return '<sdm.SybaseIQ ' + \
11978            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11979            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11980            'healthy: ' + repr(self.healthy) + ' ' +\
11981            'hostname: ' + repr(self.hostname) + ' ' +\
11982            'id: ' + repr(self.id) + ' ' +\
11983            'name: ' + repr(self.name) + ' ' +\
11984            'password: ' + repr(self.password) + ' ' +\
11985            'port: ' + repr(self.port) + ' ' +\
11986            'port_override: ' + repr(self.port_override) + ' ' +\
11987            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11988            'tags: ' + repr(self.tags) + ' ' +\
11989            'username: ' + repr(self.username) + ' ' +\
11990            '>'
11991
11992    def to_dict(self):
11993        return {
11994            'bind_interface': self.bind_interface,
11995            'egress_filter': self.egress_filter,
11996            'healthy': self.healthy,
11997            'hostname': self.hostname,
11998            'id': self.id,
11999            'name': self.name,
12000            'password': self.password,
12001            'port': self.port,
12002            'port_override': self.port_override,
12003            'secret_store_id': self.secret_store_id,
12004            'tags': self.tags,
12005            'username': self.username,
12006        }
12007
12008    @classmethod
12009    def from_dict(cls, d):
12010        return cls(
12011            bind_interface=d.get('bind_interface'),
12012            egress_filter=d.get('egress_filter'),
12013            healthy=d.get('healthy'),
12014            hostname=d.get('hostname'),
12015            id=d.get('id'),
12016            name=d.get('name'),
12017            password=d.get('password'),
12018            port=d.get('port'),
12019            port_override=d.get('port_override'),
12020            secret_store_id=d.get('secret_store_id'),
12021            tags=d.get('tags'),
12022            username=d.get('username'),
12023        )
12024
12025
12026class Tag:
12027    __slots__ = [
12028        'name',
12029        'value',
12030    ]
12031
12032    def __init__(
12033        self,
12034        name=None,
12035        value=None,
12036    ):
12037        self.name = name if name is not None else ''
12038        self.value = value if value is not None else ''
12039
12040    def __repr__(self):
12041        return '<sdm.Tag ' + \
12042            'name: ' + repr(self.name) + ' ' +\
12043            'value: ' + repr(self.value) + ' ' +\
12044            '>'
12045
12046    def to_dict(self):
12047        return {
12048            'name': self.name,
12049            'value': self.value,
12050        }
12051
12052    @classmethod
12053    def from_dict(cls, d):
12054        return cls(
12055            name=d.get('name'),
12056            value=d.get('value'),
12057        )
12058
12059
12060class Teradata:
12061    __slots__ = [
12062        'bind_interface',
12063        'egress_filter',
12064        'healthy',
12065        'hostname',
12066        'id',
12067        'name',
12068        'password',
12069        'port',
12070        'port_override',
12071        'secret_store_id',
12072        'tags',
12073        'username',
12074    ]
12075
12076    def __init__(
12077        self,
12078        bind_interface=None,
12079        egress_filter=None,
12080        healthy=None,
12081        hostname=None,
12082        id=None,
12083        name=None,
12084        password=None,
12085        port=None,
12086        port_override=None,
12087        secret_store_id=None,
12088        tags=None,
12089        username=None,
12090    ):
12091        self.bind_interface = bind_interface if bind_interface is not None else ''
12092        '''
12093         Bind interface
12094        '''
12095        self.egress_filter = egress_filter if egress_filter is not None else ''
12096        '''
12097         A filter applied to the routing logic to pin datasource to nodes.
12098        '''
12099        self.healthy = healthy if healthy is not None else False
12100        '''
12101         True if the datasource is reachable and the credentials are valid.
12102        '''
12103        self.hostname = hostname if hostname is not None else ''
12104        self.id = id if id is not None else ''
12105        '''
12106         Unique identifier of the Resource.
12107        '''
12108        self.name = name if name is not None else ''
12109        '''
12110         Unique human-readable name of the Resource.
12111        '''
12112        self.password = password if password is not None else ''
12113        self.port = port if port is not None else 0
12114        self.port_override = port_override if port_override is not None else 0
12115        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12116        '''
12117         ID of the secret store containing credentials for this resource, if any.
12118        '''
12119        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12120        '''
12121         Tags is a map of key, value pairs.
12122        '''
12123        self.username = username if username is not None else ''
12124
12125    def __repr__(self):
12126        return '<sdm.Teradata ' + \
12127            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12128            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12129            'healthy: ' + repr(self.healthy) + ' ' +\
12130            'hostname: ' + repr(self.hostname) + ' ' +\
12131            'id: ' + repr(self.id) + ' ' +\
12132            'name: ' + repr(self.name) + ' ' +\
12133            'password: ' + repr(self.password) + ' ' +\
12134            'port: ' + repr(self.port) + ' ' +\
12135            'port_override: ' + repr(self.port_override) + ' ' +\
12136            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12137            'tags: ' + repr(self.tags) + ' ' +\
12138            'username: ' + repr(self.username) + ' ' +\
12139            '>'
12140
12141    def to_dict(self):
12142        return {
12143            'bind_interface': self.bind_interface,
12144            'egress_filter': self.egress_filter,
12145            'healthy': self.healthy,
12146            'hostname': self.hostname,
12147            'id': self.id,
12148            'name': self.name,
12149            'password': self.password,
12150            'port': self.port,
12151            'port_override': self.port_override,
12152            'secret_store_id': self.secret_store_id,
12153            'tags': self.tags,
12154            'username': self.username,
12155        }
12156
12157    @classmethod
12158    def from_dict(cls, d):
12159        return cls(
12160            bind_interface=d.get('bind_interface'),
12161            egress_filter=d.get('egress_filter'),
12162            healthy=d.get('healthy'),
12163            hostname=d.get('hostname'),
12164            id=d.get('id'),
12165            name=d.get('name'),
12166            password=d.get('password'),
12167            port=d.get('port'),
12168            port_override=d.get('port_override'),
12169            secret_store_id=d.get('secret_store_id'),
12170            tags=d.get('tags'),
12171            username=d.get('username'),
12172        )
12173
12174
12175class UpdateResponseMetadata:
12176    '''
12177         UpdateResponseMetadata is reserved for future use.
12178    '''
12179    __slots__ = []
12180
12181    def __init__(self, ):
12182        pass
12183
12184    def __repr__(self):
12185        return '<sdm.UpdateResponseMetadata ' + \
12186            '>'
12187
12188    def to_dict(self):
12189        return {}
12190
12191    @classmethod
12192    def from_dict(cls, d):
12193        return cls()
12194
12195
12196class User:
12197    '''
12198         A User can connect to resources they are granted directly, or granted
12199     via roles.
12200    '''
12201    __slots__ = [
12202        'email',
12203        'external_id',
12204        'first_name',
12205        'id',
12206        'last_name',
12207        'managed_by',
12208        'permission_level',
12209        'suspended',
12210        'tags',
12211    ]
12212
12213    def __init__(
12214        self,
12215        email=None,
12216        external_id=None,
12217        first_name=None,
12218        id=None,
12219        last_name=None,
12220        managed_by=None,
12221        permission_level=None,
12222        suspended=None,
12223        tags=None,
12224    ):
12225        self.email = email if email is not None else ''
12226        '''
12227         The User's email address. Must be unique.
12228        '''
12229        self.external_id = external_id if external_id is not None else ''
12230        '''
12231         External ID is an alternative unique ID this user is represented by within an external service.
12232        '''
12233        self.first_name = first_name if first_name is not None else ''
12234        '''
12235         The User's first name.
12236        '''
12237        self.id = id if id is not None else ''
12238        '''
12239         Unique identifier of the User.
12240        '''
12241        self.last_name = last_name if last_name is not None else ''
12242        '''
12243         The User's last name.
12244        '''
12245        self.managed_by = managed_by if managed_by is not None else ''
12246        '''
12247         Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.
12248        '''
12249        self.permission_level = permission_level if permission_level is not None else ''
12250        '''
12251         PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.
12252        '''
12253        self.suspended = suspended if suspended is not None else False
12254        '''
12255         The User's suspended state.
12256        '''
12257        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12258        '''
12259         Tags is a map of key, value pairs.
12260        '''
12261
12262    def __repr__(self):
12263        return '<sdm.User ' + \
12264            'email: ' + repr(self.email) + ' ' +\
12265            'external_id: ' + repr(self.external_id) + ' ' +\
12266            'first_name: ' + repr(self.first_name) + ' ' +\
12267            'id: ' + repr(self.id) + ' ' +\
12268            'last_name: ' + repr(self.last_name) + ' ' +\
12269            'managed_by: ' + repr(self.managed_by) + ' ' +\
12270            'permission_level: ' + repr(self.permission_level) + ' ' +\
12271            'suspended: ' + repr(self.suspended) + ' ' +\
12272            'tags: ' + repr(self.tags) + ' ' +\
12273            '>'
12274
12275    def to_dict(self):
12276        return {
12277            'email': self.email,
12278            'external_id': self.external_id,
12279            'first_name': self.first_name,
12280            'id': self.id,
12281            'last_name': self.last_name,
12282            'managed_by': self.managed_by,
12283            'permission_level': self.permission_level,
12284            'suspended': self.suspended,
12285            'tags': self.tags,
12286        }
12287
12288    @classmethod
12289    def from_dict(cls, d):
12290        return cls(
12291            email=d.get('email'),
12292            external_id=d.get('external_id'),
12293            first_name=d.get('first_name'),
12294            id=d.get('id'),
12295            last_name=d.get('last_name'),
12296            managed_by=d.get('managed_by'),
12297            permission_level=d.get('permission_level'),
12298            suspended=d.get('suspended'),
12299            tags=d.get('tags'),
12300        )
12301
12302
12303class VaultAppRoleStore:
12304    __slots__ = [
12305        'id',
12306        'name',
12307        'namespace',
12308        'server_address',
12309        'tags',
12310    ]
12311
12312    def __init__(
12313        self,
12314        id=None,
12315        name=None,
12316        namespace=None,
12317        server_address=None,
12318        tags=None,
12319    ):
12320        self.id = id if id is not None else ''
12321        '''
12322         Unique identifier of the SecretStore.
12323        '''
12324        self.name = name if name is not None else ''
12325        '''
12326         Unique human-readable name of the SecretStore.
12327        '''
12328        self.namespace = namespace if namespace is not None else ''
12329        self.server_address = server_address if server_address is not None else ''
12330        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12331        '''
12332         Tags is a map of key, value pairs.
12333        '''
12334
12335    def __repr__(self):
12336        return '<sdm.VaultAppRoleStore ' + \
12337            'id: ' + repr(self.id) + ' ' +\
12338            'name: ' + repr(self.name) + ' ' +\
12339            'namespace: ' + repr(self.namespace) + ' ' +\
12340            'server_address: ' + repr(self.server_address) + ' ' +\
12341            'tags: ' + repr(self.tags) + ' ' +\
12342            '>'
12343
12344    def to_dict(self):
12345        return {
12346            'id': self.id,
12347            'name': self.name,
12348            'namespace': self.namespace,
12349            'server_address': self.server_address,
12350            'tags': self.tags,
12351        }
12352
12353    @classmethod
12354    def from_dict(cls, d):
12355        return cls(
12356            id=d.get('id'),
12357            name=d.get('name'),
12358            namespace=d.get('namespace'),
12359            server_address=d.get('server_address'),
12360            tags=d.get('tags'),
12361        )
12362
12363
12364class VaultTLSStore:
12365    __slots__ = [
12366        'ca_cert_path',
12367        'client_cert_path',
12368        'client_key_path',
12369        'id',
12370        'name',
12371        'namespace',
12372        'server_address',
12373        'tags',
12374    ]
12375
12376    def __init__(
12377        self,
12378        ca_cert_path=None,
12379        client_cert_path=None,
12380        client_key_path=None,
12381        id=None,
12382        name=None,
12383        namespace=None,
12384        server_address=None,
12385        tags=None,
12386    ):
12387        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12388        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12389        self.client_key_path = client_key_path if client_key_path is not None else ''
12390        self.id = id if id is not None else ''
12391        '''
12392         Unique identifier of the SecretStore.
12393        '''
12394        self.name = name if name is not None else ''
12395        '''
12396         Unique human-readable name of the SecretStore.
12397        '''
12398        self.namespace = namespace if namespace is not None else ''
12399        self.server_address = server_address if server_address is not None else ''
12400        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12401        '''
12402         Tags is a map of key, value pairs.
12403        '''
12404
12405    def __repr__(self):
12406        return '<sdm.VaultTLSStore ' + \
12407            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12408            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12409            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12410            'id: ' + repr(self.id) + ' ' +\
12411            'name: ' + repr(self.name) + ' ' +\
12412            'namespace: ' + repr(self.namespace) + ' ' +\
12413            'server_address: ' + repr(self.server_address) + ' ' +\
12414            'tags: ' + repr(self.tags) + ' ' +\
12415            '>'
12416
12417    def to_dict(self):
12418        return {
12419            'ca_cert_path': self.ca_cert_path,
12420            'client_cert_path': self.client_cert_path,
12421            'client_key_path': self.client_key_path,
12422            'id': self.id,
12423            'name': self.name,
12424            'namespace': self.namespace,
12425            'server_address': self.server_address,
12426            'tags': self.tags,
12427        }
12428
12429    @classmethod
12430    def from_dict(cls, d):
12431        return cls(
12432            ca_cert_path=d.get('ca_cert_path'),
12433            client_cert_path=d.get('client_cert_path'),
12434            client_key_path=d.get('client_key_path'),
12435            id=d.get('id'),
12436            name=d.get('name'),
12437            namespace=d.get('namespace'),
12438            server_address=d.get('server_address'),
12439            tags=d.get('tags'),
12440        )
12441
12442
12443class VaultTokenStore:
12444    __slots__ = [
12445        'id',
12446        'name',
12447        'namespace',
12448        'server_address',
12449        'tags',
12450    ]
12451
12452    def __init__(
12453        self,
12454        id=None,
12455        name=None,
12456        namespace=None,
12457        server_address=None,
12458        tags=None,
12459    ):
12460        self.id = id if id is not None else ''
12461        '''
12462         Unique identifier of the SecretStore.
12463        '''
12464        self.name = name if name is not None else ''
12465        '''
12466         Unique human-readable name of the SecretStore.
12467        '''
12468        self.namespace = namespace if namespace is not None else ''
12469        self.server_address = server_address if server_address is not None else ''
12470        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12471        '''
12472         Tags is a map of key, value pairs.
12473        '''
12474
12475    def __repr__(self):
12476        return '<sdm.VaultTokenStore ' + \
12477            'id: ' + repr(self.id) + ' ' +\
12478            'name: ' + repr(self.name) + ' ' +\
12479            'namespace: ' + repr(self.namespace) + ' ' +\
12480            'server_address: ' + repr(self.server_address) + ' ' +\
12481            'tags: ' + repr(self.tags) + ' ' +\
12482            '>'
12483
12484    def to_dict(self):
12485        return {
12486            'id': self.id,
12487            'name': self.name,
12488            'namespace': self.namespace,
12489            'server_address': self.server_address,
12490            'tags': self.tags,
12491        }
12492
12493    @classmethod
12494    def from_dict(cls, d):
12495        return cls(
12496            id=d.get('id'),
12497            name=d.get('name'),
12498            namespace=d.get('namespace'),
12499            server_address=d.get('server_address'),
12500            tags=d.get('tags'),
12501        )
12502
12503
12504def _porcelain_zero_value_tags():
12505    return {}
12506
12507
12508def _porcelain_zero_value_access_rules():
12509    return []
class AKS:
 22class AKS:
 23    __slots__ = [
 24        'bind_interface',
 25        'certificate_authority',
 26        'client_certificate',
 27        'client_key',
 28        'egress_filter',
 29        'healthcheck_namespace',
 30        'healthy',
 31        'hostname',
 32        'id',
 33        'name',
 34        'port',
 35        'port_override',
 36        'remote_identity_group_id',
 37        'remote_identity_healthcheck_username',
 38        'secret_store_id',
 39        'tags',
 40    ]
 41
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
101
102    def __repr__(self):
103        return '<sdm.AKS ' + \
104            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
105            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
106            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
107            'client_key: ' + repr(self.client_key) + ' ' +\
108            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
109            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
110            'healthy: ' + repr(self.healthy) + ' ' +\
111            'hostname: ' + repr(self.hostname) + ' ' +\
112            'id: ' + repr(self.id) + ' ' +\
113            'name: ' + repr(self.name) + ' ' +\
114            'port: ' + repr(self.port) + ' ' +\
115            'port_override: ' + repr(self.port_override) + ' ' +\
116            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
117            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
118            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
119            'tags: ' + repr(self.tags) + ' ' +\
120            '>'
121
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
142
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
AKS( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
 42    def __init__(
 43        self,
 44        bind_interface=None,
 45        certificate_authority=None,
 46        client_certificate=None,
 47        client_key=None,
 48        egress_filter=None,
 49        healthcheck_namespace=None,
 50        healthy=None,
 51        hostname=None,
 52        id=None,
 53        name=None,
 54        port=None,
 55        port_override=None,
 56        remote_identity_group_id=None,
 57        remote_identity_healthcheck_username=None,
 58        secret_store_id=None,
 59        tags=None,
 60    ):
 61        self.bind_interface = bind_interface if bind_interface is not None else ''
 62        '''
 63         Bind interface
 64        '''
 65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 66        self.client_certificate = client_certificate if client_certificate is not None else ''
 67        self.client_key = client_key if client_key is not None else ''
 68        self.egress_filter = egress_filter if egress_filter is not None else ''
 69        '''
 70         A filter applied to the routing logic to pin datasource to nodes.
 71        '''
 72        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 73        '''
 74         The path used to check the health of your connection.  Defaults to `default`.
 75        '''
 76        self.healthy = healthy if healthy is not None else False
 77        '''
 78         True if the datasource is reachable and the credentials are valid.
 79        '''
 80        self.hostname = hostname if hostname is not None else ''
 81        self.id = id if id is not None else ''
 82        '''
 83         Unique identifier of the Resource.
 84        '''
 85        self.name = name if name is not None else ''
 86        '''
 87         Unique human-readable name of the Resource.
 88        '''
 89        self.port = port if port is not None else 0
 90        self.port_override = port_override if port_override is not None else 0
 91        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 92        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 93        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 94        '''
 95         ID of the secret store containing credentials for this resource, if any.
 96        '''
 97        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 98        '''
 99         Tags is a map of key, value pairs.
100        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
122    def to_dict(self):
123        return {
124            'bind_interface': self.bind_interface,
125            'certificate_authority': self.certificate_authority,
126            'client_certificate': self.client_certificate,
127            'client_key': self.client_key,
128            'egress_filter': self.egress_filter,
129            'healthcheck_namespace': self.healthcheck_namespace,
130            'healthy': self.healthy,
131            'hostname': self.hostname,
132            'id': self.id,
133            'name': self.name,
134            'port': self.port,
135            'port_override': self.port_override,
136            'remote_identity_group_id': self.remote_identity_group_id,
137            'remote_identity_healthcheck_username':
138            self.remote_identity_healthcheck_username,
139            'secret_store_id': self.secret_store_id,
140            'tags': self.tags,
141        }
@classmethod
def from_dict(cls, d)
143    @classmethod
144    def from_dict(cls, d):
145        return cls(
146            bind_interface=d.get('bind_interface'),
147            certificate_authority=d.get('certificate_authority'),
148            client_certificate=d.get('client_certificate'),
149            client_key=d.get('client_key'),
150            egress_filter=d.get('egress_filter'),
151            healthcheck_namespace=d.get('healthcheck_namespace'),
152            healthy=d.get('healthy'),
153            hostname=d.get('hostname'),
154            id=d.get('id'),
155            name=d.get('name'),
156            port=d.get('port'),
157            port_override=d.get('port_override'),
158            remote_identity_group_id=d.get('remote_identity_group_id'),
159            remote_identity_healthcheck_username=d.get(
160                'remote_identity_healthcheck_username'),
161            secret_store_id=d.get('secret_store_id'),
162            tags=d.get('tags'),
163        )
class AKSBasicAuth:
166class AKSBasicAuth:
167    __slots__ = [
168        'bind_interface',
169        'egress_filter',
170        'healthcheck_namespace',
171        'healthy',
172        'hostname',
173        'id',
174        'name',
175        'password',
176        'port',
177        'port_override',
178        'secret_store_id',
179        'tags',
180        'username',
181    ]
182
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
236
237    def __repr__(self):
238        return '<sdm.AKSBasicAuth ' + \
239            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
240            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
241            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
242            'healthy: ' + repr(self.healthy) + ' ' +\
243            'hostname: ' + repr(self.hostname) + ' ' +\
244            'id: ' + repr(self.id) + ' ' +\
245            'name: ' + repr(self.name) + ' ' +\
246            'password: ' + repr(self.password) + ' ' +\
247            'port: ' + repr(self.port) + ' ' +\
248            'port_override: ' + repr(self.port_override) + ' ' +\
249            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
250            'tags: ' + repr(self.tags) + ' ' +\
251            'username: ' + repr(self.username) + ' ' +\
252            '>'
253
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
270
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
AKSBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
183    def __init__(
184        self,
185        bind_interface=None,
186        egress_filter=None,
187        healthcheck_namespace=None,
188        healthy=None,
189        hostname=None,
190        id=None,
191        name=None,
192        password=None,
193        port=None,
194        port_override=None,
195        secret_store_id=None,
196        tags=None,
197        username=None,
198    ):
199        self.bind_interface = bind_interface if bind_interface is not None else ''
200        '''
201         Bind interface
202        '''
203        self.egress_filter = egress_filter if egress_filter is not None else ''
204        '''
205         A filter applied to the routing logic to pin datasource to nodes.
206        '''
207        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
208        '''
209         The path used to check the health of your connection.  Defaults to `default`.
210        '''
211        self.healthy = healthy if healthy is not None else False
212        '''
213         True if the datasource is reachable and the credentials are valid.
214        '''
215        self.hostname = hostname if hostname is not None else ''
216        self.id = id if id is not None else ''
217        '''
218         Unique identifier of the Resource.
219        '''
220        self.name = name if name is not None else ''
221        '''
222         Unique human-readable name of the Resource.
223        '''
224        self.password = password if password is not None else ''
225        self.port = port if port is not None else 0
226        self.port_override = port_override if port_override is not None else 0
227        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
228        '''
229         ID of the secret store containing credentials for this resource, if any.
230        '''
231        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
232        '''
233         Tags is a map of key, value pairs.
234        '''
235        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
254    def to_dict(self):
255        return {
256            'bind_interface': self.bind_interface,
257            'egress_filter': self.egress_filter,
258            'healthcheck_namespace': self.healthcheck_namespace,
259            'healthy': self.healthy,
260            'hostname': self.hostname,
261            'id': self.id,
262            'name': self.name,
263            'password': self.password,
264            'port': self.port,
265            'port_override': self.port_override,
266            'secret_store_id': self.secret_store_id,
267            'tags': self.tags,
268            'username': self.username,
269        }
@classmethod
def from_dict(cls, d)
271    @classmethod
272    def from_dict(cls, d):
273        return cls(
274            bind_interface=d.get('bind_interface'),
275            egress_filter=d.get('egress_filter'),
276            healthcheck_namespace=d.get('healthcheck_namespace'),
277            healthy=d.get('healthy'),
278            hostname=d.get('hostname'),
279            id=d.get('id'),
280            name=d.get('name'),
281            password=d.get('password'),
282            port=d.get('port'),
283            port_override=d.get('port_override'),
284            secret_store_id=d.get('secret_store_id'),
285            tags=d.get('tags'),
286            username=d.get('username'),
287        )
class AKSServiceAccount:
290class AKSServiceAccount:
291    __slots__ = [
292        'bind_interface',
293        'egress_filter',
294        'healthcheck_namespace',
295        'healthy',
296        'hostname',
297        'id',
298        'name',
299        'port',
300        'port_override',
301        'remote_identity_group_id',
302        'remote_identity_healthcheck_username',
303        'secret_store_id',
304        'tags',
305        'token',
306    ]
307
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
363
364    def __repr__(self):
365        return '<sdm.AKSServiceAccount ' + \
366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
367            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
368            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
369            'healthy: ' + repr(self.healthy) + ' ' +\
370            'hostname: ' + repr(self.hostname) + ' ' +\
371            'id: ' + repr(self.id) + ' ' +\
372            'name: ' + repr(self.name) + ' ' +\
373            'port: ' + repr(self.port) + ' ' +\
374            'port_override: ' + repr(self.port_override) + ' ' +\
375            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
376            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
377            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
378            'tags: ' + repr(self.tags) + ' ' +\
379            'token: ' + repr(self.token) + ' ' +\
380            '>'
381
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
400
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
AKSServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
308    def __init__(
309        self,
310        bind_interface=None,
311        egress_filter=None,
312        healthcheck_namespace=None,
313        healthy=None,
314        hostname=None,
315        id=None,
316        name=None,
317        port=None,
318        port_override=None,
319        remote_identity_group_id=None,
320        remote_identity_healthcheck_username=None,
321        secret_store_id=None,
322        tags=None,
323        token=None,
324    ):
325        self.bind_interface = bind_interface if bind_interface is not None else ''
326        '''
327         Bind interface
328        '''
329        self.egress_filter = egress_filter if egress_filter is not None else ''
330        '''
331         A filter applied to the routing logic to pin datasource to nodes.
332        '''
333        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
334        '''
335         The path used to check the health of your connection.  Defaults to `default`.
336        '''
337        self.healthy = healthy if healthy is not None else False
338        '''
339         True if the datasource is reachable and the credentials are valid.
340        '''
341        self.hostname = hostname if hostname is not None else ''
342        self.id = id if id is not None else ''
343        '''
344         Unique identifier of the Resource.
345        '''
346        self.name = name if name is not None else ''
347        '''
348         Unique human-readable name of the Resource.
349        '''
350        self.port = port if port is not None else 0
351        self.port_override = port_override if port_override is not None else 0
352        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
353        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
355        '''
356         ID of the secret store containing credentials for this resource, if any.
357        '''
358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
359        '''
360         Tags is a map of key, value pairs.
361        '''
362        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
382    def to_dict(self):
383        return {
384            'bind_interface': self.bind_interface,
385            'egress_filter': self.egress_filter,
386            'healthcheck_namespace': self.healthcheck_namespace,
387            'healthy': self.healthy,
388            'hostname': self.hostname,
389            'id': self.id,
390            'name': self.name,
391            'port': self.port,
392            'port_override': self.port_override,
393            'remote_identity_group_id': self.remote_identity_group_id,
394            'remote_identity_healthcheck_username':
395            self.remote_identity_healthcheck_username,
396            'secret_store_id': self.secret_store_id,
397            'tags': self.tags,
398            'token': self.token,
399        }
@classmethod
def from_dict(cls, d)
401    @classmethod
402    def from_dict(cls, d):
403        return cls(
404            bind_interface=d.get('bind_interface'),
405            egress_filter=d.get('egress_filter'),
406            healthcheck_namespace=d.get('healthcheck_namespace'),
407            healthy=d.get('healthy'),
408            hostname=d.get('hostname'),
409            id=d.get('id'),
410            name=d.get('name'),
411            port=d.get('port'),
412            port_override=d.get('port_override'),
413            remote_identity_group_id=d.get('remote_identity_group_id'),
414            remote_identity_healthcheck_username=d.get(
415                'remote_identity_healthcheck_username'),
416            secret_store_id=d.get('secret_store_id'),
417            tags=d.get('tags'),
418            token=d.get('token'),
419        )
class AKSServiceAccountUserImpersonation:
422class AKSServiceAccountUserImpersonation:
423    __slots__ = [
424        'bind_interface',
425        'egress_filter',
426        'healthcheck_namespace',
427        'healthy',
428        'hostname',
429        'id',
430        'name',
431        'port',
432        'port_override',
433        'secret_store_id',
434        'tags',
435        'token',
436    ]
437
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
489
490    def __repr__(self):
491        return '<sdm.AKSServiceAccountUserImpersonation ' + \
492            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
493            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
494            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
495            'healthy: ' + repr(self.healthy) + ' ' +\
496            'hostname: ' + repr(self.hostname) + ' ' +\
497            'id: ' + repr(self.id) + ' ' +\
498            'name: ' + repr(self.name) + ' ' +\
499            'port: ' + repr(self.port) + ' ' +\
500            'port_override: ' + repr(self.port_override) + ' ' +\
501            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
502            'tags: ' + repr(self.tags) + ' ' +\
503            'token: ' + repr(self.token) + ' ' +\
504            '>'
505
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
521
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
AKSServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
438    def __init__(
439        self,
440        bind_interface=None,
441        egress_filter=None,
442        healthcheck_namespace=None,
443        healthy=None,
444        hostname=None,
445        id=None,
446        name=None,
447        port=None,
448        port_override=None,
449        secret_store_id=None,
450        tags=None,
451        token=None,
452    ):
453        self.bind_interface = bind_interface if bind_interface is not None else ''
454        '''
455         Bind interface
456        '''
457        self.egress_filter = egress_filter if egress_filter is not None else ''
458        '''
459         A filter applied to the routing logic to pin datasource to nodes.
460        '''
461        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
462        '''
463         The path used to check the health of your connection.  Defaults to `default`.
464        '''
465        self.healthy = healthy if healthy is not None else False
466        '''
467         True if the datasource is reachable and the credentials are valid.
468        '''
469        self.hostname = hostname if hostname is not None else ''
470        self.id = id if id is not None else ''
471        '''
472         Unique identifier of the Resource.
473        '''
474        self.name = name if name is not None else ''
475        '''
476         Unique human-readable name of the Resource.
477        '''
478        self.port = port if port is not None else 0
479        self.port_override = port_override if port_override is not None else 0
480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
481        '''
482         ID of the secret store containing credentials for this resource, if any.
483        '''
484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
485        '''
486         Tags is a map of key, value pairs.
487        '''
488        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
506    def to_dict(self):
507        return {
508            'bind_interface': self.bind_interface,
509            'egress_filter': self.egress_filter,
510            'healthcheck_namespace': self.healthcheck_namespace,
511            'healthy': self.healthy,
512            'hostname': self.hostname,
513            'id': self.id,
514            'name': self.name,
515            'port': self.port,
516            'port_override': self.port_override,
517            'secret_store_id': self.secret_store_id,
518            'tags': self.tags,
519            'token': self.token,
520        }
@classmethod
def from_dict(cls, d)
522    @classmethod
523    def from_dict(cls, d):
524        return cls(
525            bind_interface=d.get('bind_interface'),
526            egress_filter=d.get('egress_filter'),
527            healthcheck_namespace=d.get('healthcheck_namespace'),
528            healthy=d.get('healthy'),
529            hostname=d.get('hostname'),
530            id=d.get('id'),
531            name=d.get('name'),
532            port=d.get('port'),
533            port_override=d.get('port_override'),
534            secret_store_id=d.get('secret_store_id'),
535            tags=d.get('tags'),
536            token=d.get('token'),
537        )
class AKSUserImpersonation:
540class AKSUserImpersonation:
541    __slots__ = [
542        'bind_interface',
543        'certificate_authority',
544        'client_certificate',
545        'client_key',
546        'egress_filter',
547        'healthcheck_namespace',
548        'healthy',
549        'hostname',
550        'id',
551        'name',
552        'port',
553        'port_override',
554        'secret_store_id',
555        'tags',
556    ]
557
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
613
614    def __repr__(self):
615        return '<sdm.AKSUserImpersonation ' + \
616            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
617            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
618            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
619            'client_key: ' + repr(self.client_key) + ' ' +\
620            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
621            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
622            'healthy: ' + repr(self.healthy) + ' ' +\
623            'hostname: ' + repr(self.hostname) + ' ' +\
624            'id: ' + repr(self.id) + ' ' +\
625            'name: ' + repr(self.name) + ' ' +\
626            'port: ' + repr(self.port) + ' ' +\
627            'port_override: ' + repr(self.port_override) + ' ' +\
628            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
629            'tags: ' + repr(self.tags) + ' ' +\
630            '>'
631
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
649
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
AKSUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
558    def __init__(
559        self,
560        bind_interface=None,
561        certificate_authority=None,
562        client_certificate=None,
563        client_key=None,
564        egress_filter=None,
565        healthcheck_namespace=None,
566        healthy=None,
567        hostname=None,
568        id=None,
569        name=None,
570        port=None,
571        port_override=None,
572        secret_store_id=None,
573        tags=None,
574    ):
575        self.bind_interface = bind_interface if bind_interface is not None else ''
576        '''
577         Bind interface
578        '''
579        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
580        self.client_certificate = client_certificate if client_certificate is not None else ''
581        self.client_key = client_key if client_key is not None else ''
582        self.egress_filter = egress_filter if egress_filter is not None else ''
583        '''
584         A filter applied to the routing logic to pin datasource to nodes.
585        '''
586        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
587        '''
588         The path used to check the health of your connection.  Defaults to `default`.
589        '''
590        self.healthy = healthy if healthy is not None else False
591        '''
592         True if the datasource is reachable and the credentials are valid.
593        '''
594        self.hostname = hostname if hostname is not None else ''
595        self.id = id if id is not None else ''
596        '''
597         Unique identifier of the Resource.
598        '''
599        self.name = name if name is not None else ''
600        '''
601         Unique human-readable name of the Resource.
602        '''
603        self.port = port if port is not None else 0
604        self.port_override = port_override if port_override is not None else 0
605        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
606        '''
607         ID of the secret store containing credentials for this resource, if any.
608        '''
609        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
610        '''
611         Tags is a map of key, value pairs.
612        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
632    def to_dict(self):
633        return {
634            'bind_interface': self.bind_interface,
635            'certificate_authority': self.certificate_authority,
636            'client_certificate': self.client_certificate,
637            'client_key': self.client_key,
638            'egress_filter': self.egress_filter,
639            'healthcheck_namespace': self.healthcheck_namespace,
640            'healthy': self.healthy,
641            'hostname': self.hostname,
642            'id': self.id,
643            'name': self.name,
644            'port': self.port,
645            'port_override': self.port_override,
646            'secret_store_id': self.secret_store_id,
647            'tags': self.tags,
648        }
@classmethod
def from_dict(cls, d)
650    @classmethod
651    def from_dict(cls, d):
652        return cls(
653            bind_interface=d.get('bind_interface'),
654            certificate_authority=d.get('certificate_authority'),
655            client_certificate=d.get('client_certificate'),
656            client_key=d.get('client_key'),
657            egress_filter=d.get('egress_filter'),
658            healthcheck_namespace=d.get('healthcheck_namespace'),
659            healthy=d.get('healthy'),
660            hostname=d.get('hostname'),
661            id=d.get('id'),
662            name=d.get('name'),
663            port=d.get('port'),
664            port_override=d.get('port_override'),
665            secret_store_id=d.get('secret_store_id'),
666            tags=d.get('tags'),
667        )
class AWS:
670class AWS:
671    __slots__ = [
672        'access_key',
673        'bind_interface',
674        'egress_filter',
675        'healthcheck_region',
676        'healthy',
677        'id',
678        'name',
679        'role_arn',
680        'role_external_id',
681        'secret_access_key',
682        'secret_store_id',
683        'tags',
684    ]
685
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
734
735    def __repr__(self):
736        return '<sdm.AWS ' + \
737            'access_key: ' + repr(self.access_key) + ' ' +\
738            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
739            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
740            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
741            'healthy: ' + repr(self.healthy) + ' ' +\
742            'id: ' + repr(self.id) + ' ' +\
743            'name: ' + repr(self.name) + ' ' +\
744            'role_arn: ' + repr(self.role_arn) + ' ' +\
745            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
746            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
747            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
748            'tags: ' + repr(self.tags) + ' ' +\
749            '>'
750
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
766
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
AWS( access_key=None, bind_interface=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
686    def __init__(
687        self,
688        access_key=None,
689        bind_interface=None,
690        egress_filter=None,
691        healthcheck_region=None,
692        healthy=None,
693        id=None,
694        name=None,
695        role_arn=None,
696        role_external_id=None,
697        secret_access_key=None,
698        secret_store_id=None,
699        tags=None,
700    ):
701        self.access_key = access_key if access_key is not None else ''
702        self.bind_interface = bind_interface if bind_interface is not None else ''
703        '''
704         Bind interface
705        '''
706        self.egress_filter = egress_filter if egress_filter is not None else ''
707        '''
708         A filter applied to the routing logic to pin datasource to nodes.
709        '''
710        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
711        self.healthy = healthy if healthy is not None else False
712        '''
713         True if the datasource is reachable and the credentials are valid.
714        '''
715        self.id = id if id is not None else ''
716        '''
717         Unique identifier of the Resource.
718        '''
719        self.name = name if name is not None else ''
720        '''
721         Unique human-readable name of the Resource.
722        '''
723        self.role_arn = role_arn if role_arn is not None else ''
724        self.role_external_id = role_external_id if role_external_id is not None else ''
725        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
726        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
727        '''
728         ID of the secret store containing credentials for this resource, if any.
729        '''
730        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
731        '''
732         Tags is a map of key, value pairs.
733        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_region
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
751    def to_dict(self):
752        return {
753            'access_key': self.access_key,
754            'bind_interface': self.bind_interface,
755            'egress_filter': self.egress_filter,
756            'healthcheck_region': self.healthcheck_region,
757            'healthy': self.healthy,
758            'id': self.id,
759            'name': self.name,
760            'role_arn': self.role_arn,
761            'role_external_id': self.role_external_id,
762            'secret_access_key': self.secret_access_key,
763            'secret_store_id': self.secret_store_id,
764            'tags': self.tags,
765        }
@classmethod
def from_dict(cls, d)
767    @classmethod
768    def from_dict(cls, d):
769        return cls(
770            access_key=d.get('access_key'),
771            bind_interface=d.get('bind_interface'),
772            egress_filter=d.get('egress_filter'),
773            healthcheck_region=d.get('healthcheck_region'),
774            healthy=d.get('healthy'),
775            id=d.get('id'),
776            name=d.get('name'),
777            role_arn=d.get('role_arn'),
778            role_external_id=d.get('role_external_id'),
779            secret_access_key=d.get('secret_access_key'),
780            secret_store_id=d.get('secret_store_id'),
781            tags=d.get('tags'),
782        )
class AWSConsole:
785class AWSConsole:
786    '''
787    AWSConsole is currently unstable, and its API may change, or it may be removed,
788    without a major version bump.
789    '''
790    __slots__ = [
791        'bind_interface',
792        'egress_filter',
793        'enable_env_variables',
794        'healthy',
795        'id',
796        'name',
797        'port_override',
798        'region',
799        'remote_identity_group_id',
800        'remote_identity_healthcheck_username',
801        'role_arn',
802        'role_external_id',
803        'secret_store_id',
804        'session_expiry',
805        'subdomain',
806        'tags',
807    ]
808
809    def __init__(
810        self,
811        bind_interface=None,
812        egress_filter=None,
813        enable_env_variables=None,
814        healthy=None,
815        id=None,
816        name=None,
817        port_override=None,
818        region=None,
819        remote_identity_group_id=None,
820        remote_identity_healthcheck_username=None,
821        role_arn=None,
822        role_external_id=None,
823        secret_store_id=None,
824        session_expiry=None,
825        subdomain=None,
826        tags=None,
827    ):
828        self.bind_interface = bind_interface if bind_interface is not None else ''
829        '''
830         Bind interface
831        '''
832        self.egress_filter = egress_filter if egress_filter is not None else ''
833        '''
834         A filter applied to the routing logic to pin datasource to nodes.
835        '''
836        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
837        self.healthy = healthy if healthy is not None else False
838        '''
839         True if the datasource is reachable and the credentials are valid.
840        '''
841        self.id = id if id is not None else ''
842        '''
843         Unique identifier of the Resource.
844        '''
845        self.name = name if name is not None else ''
846        '''
847         Unique human-readable name of the Resource.
848        '''
849        self.port_override = port_override if port_override is not None else 0
850        self.region = region if region is not None else ''
851        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
852        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
853        self.role_arn = role_arn if role_arn is not None else ''
854        self.role_external_id = role_external_id if role_external_id is not None else ''
855        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
856        '''
857         ID of the secret store containing credentials for this resource, if any.
858        '''
859        self.session_expiry = session_expiry if session_expiry is not None else 0
860        self.subdomain = subdomain if subdomain is not None else ''
861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
862        '''
863         Tags is a map of key, value pairs.
864        '''
865
866    def __repr__(self):
867        return '<sdm.AWSConsole ' + \
868            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
869            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
870            'enable_env_variables: ' + repr(self.enable_env_variables) + ' ' +\
871            'healthy: ' + repr(self.healthy) + ' ' +\
872            'id: ' + repr(self.id) + ' ' +\
873            'name: ' + repr(self.name) + ' ' +\
874            'port_override: ' + repr(self.port_override) + ' ' +\
875            'region: ' + repr(self.region) + ' ' +\
876            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
877            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
878            'role_arn: ' + repr(self.role_arn) + ' ' +\
879            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
880            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
881            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
882            'subdomain: ' + repr(self.subdomain) + ' ' +\
883            'tags: ' + repr(self.tags) + ' ' +\
884            '>'
885
886    def to_dict(self):
887        return {
888            'bind_interface': self.bind_interface,
889            'egress_filter': self.egress_filter,
890            'enable_env_variables': self.enable_env_variables,
891            'healthy': self.healthy,
892            'id': self.id,
893            'name': self.name,
894            'port_override': self.port_override,
895            'region': self.region,
896            'remote_identity_group_id': self.remote_identity_group_id,
897            'remote_identity_healthcheck_username':
898            self.remote_identity_healthcheck_username,
899            'role_arn': self.role_arn,
900            'role_external_id': self.role_external_id,
901            'secret_store_id': self.secret_store_id,
902            'session_expiry': self.session_expiry,
903            'subdomain': self.subdomain,
904            'tags': self.tags,
905        }
906
907    @classmethod
908    def from_dict(cls, d):
909        return cls(
910            bind_interface=d.get('bind_interface'),
911            egress_filter=d.get('egress_filter'),
912            enable_env_variables=d.get('enable_env_variables'),
913            healthy=d.get('healthy'),
914            id=d.get('id'),
915            name=d.get('name'),
916            port_override=d.get('port_override'),
917            region=d.get('region'),
918            remote_identity_group_id=d.get('remote_identity_group_id'),
919            remote_identity_healthcheck_username=d.get(
920                'remote_identity_healthcheck_username'),
921            role_arn=d.get('role_arn'),
922            role_external_id=d.get('role_external_id'),
923            secret_store_id=d.get('secret_store_id'),
924            session_expiry=d.get('session_expiry'),
925            subdomain=d.get('subdomain'),
926            tags=d.get('tags'),
927        )

AWSConsole is currently unstable, and its API may change, or it may be removed, without a major version bump.

AWSConsole( bind_interface=None, egress_filter=None, enable_env_variables=None, healthy=None, id=None, name=None, port_override=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_store_id=None, session_expiry=None, subdomain=None, tags=None)
809    def __init__(
810        self,
811        bind_interface=None,
812        egress_filter=None,
813        enable_env_variables=None,
814        healthy=None,
815        id=None,
816        name=None,
817        port_override=None,
818        region=None,
819        remote_identity_group_id=None,
820        remote_identity_healthcheck_username=None,
821        role_arn=None,
822        role_external_id=None,
823        secret_store_id=None,
824        session_expiry=None,
825        subdomain=None,
826        tags=None,
827    ):
828        self.bind_interface = bind_interface if bind_interface is not None else ''
829        '''
830         Bind interface
831        '''
832        self.egress_filter = egress_filter if egress_filter is not None else ''
833        '''
834         A filter applied to the routing logic to pin datasource to nodes.
835        '''
836        self.enable_env_variables = enable_env_variables if enable_env_variables is not None else False
837        self.healthy = healthy if healthy is not None else False
838        '''
839         True if the datasource is reachable and the credentials are valid.
840        '''
841        self.id = id if id is not None else ''
842        '''
843         Unique identifier of the Resource.
844        '''
845        self.name = name if name is not None else ''
846        '''
847         Unique human-readable name of the Resource.
848        '''
849        self.port_override = port_override if port_override is not None else 0
850        self.region = region if region is not None else ''
851        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
852        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
853        self.role_arn = role_arn if role_arn is not None else ''
854        self.role_external_id = role_external_id if role_external_id is not None else ''
855        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
856        '''
857         ID of the secret store containing credentials for this resource, if any.
858        '''
859        self.session_expiry = session_expiry if session_expiry is not None else 0
860        self.subdomain = subdomain if subdomain is not None else ''
861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
862        '''
863         Tags is a map of key, value pairs.
864        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

enable_env_variables
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_store_id

ID of the secret store containing credentials for this resource, if any.

session_expiry
subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
886    def to_dict(self):
887        return {
888            'bind_interface': self.bind_interface,
889            'egress_filter': self.egress_filter,
890            'enable_env_variables': self.enable_env_variables,
891            'healthy': self.healthy,
892            'id': self.id,
893            'name': self.name,
894            'port_override': self.port_override,
895            'region': self.region,
896            'remote_identity_group_id': self.remote_identity_group_id,
897            'remote_identity_healthcheck_username':
898            self.remote_identity_healthcheck_username,
899            'role_arn': self.role_arn,
900            'role_external_id': self.role_external_id,
901            'secret_store_id': self.secret_store_id,
902            'session_expiry': self.session_expiry,
903            'subdomain': self.subdomain,
904            'tags': self.tags,
905        }
@classmethod
def from_dict(cls, d)
907    @classmethod
908    def from_dict(cls, d):
909        return cls(
910            bind_interface=d.get('bind_interface'),
911            egress_filter=d.get('egress_filter'),
912            enable_env_variables=d.get('enable_env_variables'),
913            healthy=d.get('healthy'),
914            id=d.get('id'),
915            name=d.get('name'),
916            port_override=d.get('port_override'),
917            region=d.get('region'),
918            remote_identity_group_id=d.get('remote_identity_group_id'),
919            remote_identity_healthcheck_username=d.get(
920                'remote_identity_healthcheck_username'),
921            role_arn=d.get('role_arn'),
922            role_external_id=d.get('role_external_id'),
923            secret_store_id=d.get('secret_store_id'),
924            session_expiry=d.get('session_expiry'),
925            subdomain=d.get('subdomain'),
926            tags=d.get('tags'),
927        )
class AWSConsoleStaticKeyPair:
 930class AWSConsoleStaticKeyPair:
 931    '''
 932    AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed,
 933    without a major version bump.
 934    '''
 935    __slots__ = [
 936        'access_key',
 937        'bind_interface',
 938        'egress_filter',
 939        'healthy',
 940        'id',
 941        'name',
 942        'port_override',
 943        'region',
 944        'remote_identity_group_id',
 945        'remote_identity_healthcheck_username',
 946        'role_arn',
 947        'role_external_id',
 948        'secret_access_key',
 949        'secret_store_id',
 950        'session_expiry',
 951        'subdomain',
 952        'tags',
 953    ]
 954
 955    def __init__(
 956        self,
 957        access_key=None,
 958        bind_interface=None,
 959        egress_filter=None,
 960        healthy=None,
 961        id=None,
 962        name=None,
 963        port_override=None,
 964        region=None,
 965        remote_identity_group_id=None,
 966        remote_identity_healthcheck_username=None,
 967        role_arn=None,
 968        role_external_id=None,
 969        secret_access_key=None,
 970        secret_store_id=None,
 971        session_expiry=None,
 972        subdomain=None,
 973        tags=None,
 974    ):
 975        self.access_key = access_key if access_key is not None else ''
 976        self.bind_interface = bind_interface if bind_interface is not None else ''
 977        '''
 978         Bind interface
 979        '''
 980        self.egress_filter = egress_filter if egress_filter is not None else ''
 981        '''
 982         A filter applied to the routing logic to pin datasource to nodes.
 983        '''
 984        self.healthy = healthy if healthy is not None else False
 985        '''
 986         True if the datasource is reachable and the credentials are valid.
 987        '''
 988        self.id = id if id is not None else ''
 989        '''
 990         Unique identifier of the Resource.
 991        '''
 992        self.name = name if name is not None else ''
 993        '''
 994         Unique human-readable name of the Resource.
 995        '''
 996        self.port_override = port_override if port_override is not None else 0
 997        self.region = region if region is not None else ''
 998        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 999        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1000        self.role_arn = role_arn if role_arn is not None else ''
1001        self.role_external_id = role_external_id if role_external_id is not None else ''
1002        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1004        '''
1005         ID of the secret store containing credentials for this resource, if any.
1006        '''
1007        self.session_expiry = session_expiry if session_expiry is not None else 0
1008        self.subdomain = subdomain if subdomain is not None else ''
1009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1010        '''
1011         Tags is a map of key, value pairs.
1012        '''
1013
1014    def __repr__(self):
1015        return '<sdm.AWSConsoleStaticKeyPair ' + \
1016            'access_key: ' + repr(self.access_key) + ' ' +\
1017            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1018            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1019            'healthy: ' + repr(self.healthy) + ' ' +\
1020            'id: ' + repr(self.id) + ' ' +\
1021            'name: ' + repr(self.name) + ' ' +\
1022            'port_override: ' + repr(self.port_override) + ' ' +\
1023            'region: ' + repr(self.region) + ' ' +\
1024            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1025            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1026            'role_arn: ' + repr(self.role_arn) + ' ' +\
1027            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1028            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1029            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1030            'session_expiry: ' + repr(self.session_expiry) + ' ' +\
1031            'subdomain: ' + repr(self.subdomain) + ' ' +\
1032            'tags: ' + repr(self.tags) + ' ' +\
1033            '>'
1034
1035    def to_dict(self):
1036        return {
1037            'access_key': self.access_key,
1038            'bind_interface': self.bind_interface,
1039            'egress_filter': self.egress_filter,
1040            'healthy': self.healthy,
1041            'id': self.id,
1042            'name': self.name,
1043            'port_override': self.port_override,
1044            'region': self.region,
1045            'remote_identity_group_id': self.remote_identity_group_id,
1046            'remote_identity_healthcheck_username':
1047            self.remote_identity_healthcheck_username,
1048            'role_arn': self.role_arn,
1049            'role_external_id': self.role_external_id,
1050            'secret_access_key': self.secret_access_key,
1051            'secret_store_id': self.secret_store_id,
1052            'session_expiry': self.session_expiry,
1053            'subdomain': self.subdomain,
1054            'tags': self.tags,
1055        }
1056
1057    @classmethod
1058    def from_dict(cls, d):
1059        return cls(
1060            access_key=d.get('access_key'),
1061            bind_interface=d.get('bind_interface'),
1062            egress_filter=d.get('egress_filter'),
1063            healthy=d.get('healthy'),
1064            id=d.get('id'),
1065            name=d.get('name'),
1066            port_override=d.get('port_override'),
1067            region=d.get('region'),
1068            remote_identity_group_id=d.get('remote_identity_group_id'),
1069            remote_identity_healthcheck_username=d.get(
1070                'remote_identity_healthcheck_username'),
1071            role_arn=d.get('role_arn'),
1072            role_external_id=d.get('role_external_id'),
1073            secret_access_key=d.get('secret_access_key'),
1074            secret_store_id=d.get('secret_store_id'),
1075            session_expiry=d.get('session_expiry'),
1076            subdomain=d.get('subdomain'),
1077            tags=d.get('tags'),
1078        )

AWSConsoleStaticKeyPair is currently unstable, and its API may change, or it may be removed, without a major version bump.

AWSConsoleStaticKeyPair( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, port_override=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, session_expiry=None, subdomain=None, tags=None)
 955    def __init__(
 956        self,
 957        access_key=None,
 958        bind_interface=None,
 959        egress_filter=None,
 960        healthy=None,
 961        id=None,
 962        name=None,
 963        port_override=None,
 964        region=None,
 965        remote_identity_group_id=None,
 966        remote_identity_healthcheck_username=None,
 967        role_arn=None,
 968        role_external_id=None,
 969        secret_access_key=None,
 970        secret_store_id=None,
 971        session_expiry=None,
 972        subdomain=None,
 973        tags=None,
 974    ):
 975        self.access_key = access_key if access_key is not None else ''
 976        self.bind_interface = bind_interface if bind_interface is not None else ''
 977        '''
 978         Bind interface
 979        '''
 980        self.egress_filter = egress_filter if egress_filter is not None else ''
 981        '''
 982         A filter applied to the routing logic to pin datasource to nodes.
 983        '''
 984        self.healthy = healthy if healthy is not None else False
 985        '''
 986         True if the datasource is reachable and the credentials are valid.
 987        '''
 988        self.id = id if id is not None else ''
 989        '''
 990         Unique identifier of the Resource.
 991        '''
 992        self.name = name if name is not None else ''
 993        '''
 994         Unique human-readable name of the Resource.
 995        '''
 996        self.port_override = port_override if port_override is not None else 0
 997        self.region = region if region is not None else ''
 998        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 999        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1000        self.role_arn = role_arn if role_arn is not None else ''
1001        self.role_external_id = role_external_id if role_external_id is not None else ''
1002        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1004        '''
1005         ID of the secret store containing credentials for this resource, if any.
1006        '''
1007        self.session_expiry = session_expiry if session_expiry is not None else 0
1008        self.subdomain = subdomain if subdomain is not None else ''
1009        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1010        '''
1011         Tags is a map of key, value pairs.
1012        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

session_expiry
subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
1035    def to_dict(self):
1036        return {
1037            'access_key': self.access_key,
1038            'bind_interface': self.bind_interface,
1039            'egress_filter': self.egress_filter,
1040            'healthy': self.healthy,
1041            'id': self.id,
1042            'name': self.name,
1043            'port_override': self.port_override,
1044            'region': self.region,
1045            'remote_identity_group_id': self.remote_identity_group_id,
1046            'remote_identity_healthcheck_username':
1047            self.remote_identity_healthcheck_username,
1048            'role_arn': self.role_arn,
1049            'role_external_id': self.role_external_id,
1050            'secret_access_key': self.secret_access_key,
1051            'secret_store_id': self.secret_store_id,
1052            'session_expiry': self.session_expiry,
1053            'subdomain': self.subdomain,
1054            'tags': self.tags,
1055        }
@classmethod
def from_dict(cls, d)
1057    @classmethod
1058    def from_dict(cls, d):
1059        return cls(
1060            access_key=d.get('access_key'),
1061            bind_interface=d.get('bind_interface'),
1062            egress_filter=d.get('egress_filter'),
1063            healthy=d.get('healthy'),
1064            id=d.get('id'),
1065            name=d.get('name'),
1066            port_override=d.get('port_override'),
1067            region=d.get('region'),
1068            remote_identity_group_id=d.get('remote_identity_group_id'),
1069            remote_identity_healthcheck_username=d.get(
1070                'remote_identity_healthcheck_username'),
1071            role_arn=d.get('role_arn'),
1072            role_external_id=d.get('role_external_id'),
1073            secret_access_key=d.get('secret_access_key'),
1074            secret_store_id=d.get('secret_store_id'),
1075            session_expiry=d.get('session_expiry'),
1076            subdomain=d.get('subdomain'),
1077            tags=d.get('tags'),
1078        )
class AWSStore:
1081class AWSStore:
1082    __slots__ = [
1083        'id',
1084        'name',
1085        'region',
1086        'tags',
1087    ]
1088
1089    def __init__(
1090        self,
1091        id=None,
1092        name=None,
1093        region=None,
1094        tags=None,
1095    ):
1096        self.id = id if id is not None else ''
1097        '''
1098         Unique identifier of the SecretStore.
1099        '''
1100        self.name = name if name is not None else ''
1101        '''
1102         Unique human-readable name of the SecretStore.
1103        '''
1104        self.region = region if region is not None else ''
1105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1106        '''
1107         Tags is a map of key, value pairs.
1108        '''
1109
1110    def __repr__(self):
1111        return '<sdm.AWSStore ' + \
1112            'id: ' + repr(self.id) + ' ' +\
1113            'name: ' + repr(self.name) + ' ' +\
1114            'region: ' + repr(self.region) + ' ' +\
1115            'tags: ' + repr(self.tags) + ' ' +\
1116            '>'
1117
1118    def to_dict(self):
1119        return {
1120            'id': self.id,
1121            'name': self.name,
1122            'region': self.region,
1123            'tags': self.tags,
1124        }
1125
1126    @classmethod
1127    def from_dict(cls, d):
1128        return cls(
1129            id=d.get('id'),
1130            name=d.get('name'),
1131            region=d.get('region'),
1132            tags=d.get('tags'),
1133        )
AWSStore(id=None, name=None, region=None, tags=None)
1089    def __init__(
1090        self,
1091        id=None,
1092        name=None,
1093        region=None,
1094        tags=None,
1095    ):
1096        self.id = id if id is not None else ''
1097        '''
1098         Unique identifier of the SecretStore.
1099        '''
1100        self.name = name if name is not None else ''
1101        '''
1102         Unique human-readable name of the SecretStore.
1103        '''
1104        self.region = region if region is not None else ''
1105        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1106        '''
1107         Tags is a map of key, value pairs.
1108        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

region
tags

Tags is a map of key, value pairs.

def to_dict(self)
1118    def to_dict(self):
1119        return {
1120            'id': self.id,
1121            'name': self.name,
1122            'region': self.region,
1123            'tags': self.tags,
1124        }
@classmethod
def from_dict(cls, d)
1126    @classmethod
1127    def from_dict(cls, d):
1128        return cls(
1129            id=d.get('id'),
1130            name=d.get('name'),
1131            region=d.get('region'),
1132            tags=d.get('tags'),
1133        )
class AccountAttachment:
1136class AccountAttachment:
1137    '''
1138         AccountAttachments assign an account to a role.
1139    '''
1140    __slots__ = [
1141        'account_id',
1142        'id',
1143        'role_id',
1144    ]
1145
1146    def __init__(
1147        self,
1148        account_id=None,
1149        id=None,
1150        role_id=None,
1151    ):
1152        self.account_id = account_id if account_id is not None else ''
1153        '''
1154         The id of the account of this AccountAttachment.
1155        '''
1156        self.id = id if id is not None else ''
1157        '''
1158         Unique identifier of the AccountAttachment.
1159        '''
1160        self.role_id = role_id if role_id is not None else ''
1161        '''
1162         The id of the attached role of this AccountAttachment.
1163        '''
1164
1165    def __repr__(self):
1166        return '<sdm.AccountAttachment ' + \
1167            'account_id: ' + repr(self.account_id) + ' ' +\
1168            'id: ' + repr(self.id) + ' ' +\
1169            'role_id: ' + repr(self.role_id) + ' ' +\
1170            '>'
1171
1172    def to_dict(self):
1173        return {
1174            'account_id': self.account_id,
1175            'id': self.id,
1176            'role_id': self.role_id,
1177        }
1178
1179    @classmethod
1180    def from_dict(cls, d):
1181        return cls(
1182            account_id=d.get('account_id'),
1183            id=d.get('id'),
1184            role_id=d.get('role_id'),
1185        )

AccountAttachments assign an account to a role.

AccountAttachment(account_id=None, id=None, role_id=None)
1146    def __init__(
1147        self,
1148        account_id=None,
1149        id=None,
1150        role_id=None,
1151    ):
1152        self.account_id = account_id if account_id is not None else ''
1153        '''
1154         The id of the account of this AccountAttachment.
1155        '''
1156        self.id = id if id is not None else ''
1157        '''
1158         Unique identifier of the AccountAttachment.
1159        '''
1160        self.role_id = role_id if role_id is not None else ''
1161        '''
1162         The id of the attached role of this AccountAttachment.
1163        '''
account_id

The id of the account of this AccountAttachment.

id

Unique identifier of the AccountAttachment.

role_id

The id of the attached role of this AccountAttachment.

def to_dict(self)
1172    def to_dict(self):
1173        return {
1174            'account_id': self.account_id,
1175            'id': self.id,
1176            'role_id': self.role_id,
1177        }
@classmethod
def from_dict(cls, d)
1179    @classmethod
1180    def from_dict(cls, d):
1181        return cls(
1182            account_id=d.get('account_id'),
1183            id=d.get('id'),
1184            role_id=d.get('role_id'),
1185        )
class AccountAttachmentCreateResponse:
1188class AccountAttachmentCreateResponse:
1189    '''
1190         AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
1191    '''
1192    __slots__ = [
1193        'account_attachment',
1194        'meta',
1195        'rate_limit',
1196    ]
1197
1198    def __init__(
1199        self,
1200        account_attachment=None,
1201        meta=None,
1202        rate_limit=None,
1203    ):
1204        self.account_attachment = account_attachment if account_attachment is not None else None
1205        '''
1206         The created AccountAttachment.
1207        '''
1208        self.meta = meta if meta is not None else None
1209        '''
1210         Reserved for future use.
1211        '''
1212        self.rate_limit = rate_limit if rate_limit is not None else None
1213        '''
1214         Rate limit information.
1215        '''
1216
1217    def __repr__(self):
1218        return '<sdm.AccountAttachmentCreateResponse ' + \
1219            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1220            'meta: ' + repr(self.meta) + ' ' +\
1221            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1222            '>'
1223
1224    def to_dict(self):
1225        return {
1226            'account_attachment': self.account_attachment,
1227            'meta': self.meta,
1228            'rate_limit': self.rate_limit,
1229        }
1230
1231    @classmethod
1232    def from_dict(cls, d):
1233        return cls(
1234            account_attachment=d.get('account_attachment'),
1235            meta=d.get('meta'),
1236            rate_limit=d.get('rate_limit'),
1237        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
1198    def __init__(
1199        self,
1200        account_attachment=None,
1201        meta=None,
1202        rate_limit=None,
1203    ):
1204        self.account_attachment = account_attachment if account_attachment is not None else None
1205        '''
1206         The created AccountAttachment.
1207        '''
1208        self.meta = meta if meta is not None else None
1209        '''
1210         Reserved for future use.
1211        '''
1212        self.rate_limit = rate_limit if rate_limit is not None else None
1213        '''
1214         Rate limit information.
1215        '''
account_attachment

The created AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1224    def to_dict(self):
1225        return {
1226            'account_attachment': self.account_attachment,
1227            'meta': self.meta,
1228            'rate_limit': self.rate_limit,
1229        }
@classmethod
def from_dict(cls, d)
1231    @classmethod
1232    def from_dict(cls, d):
1233        return cls(
1234            account_attachment=d.get('account_attachment'),
1235            meta=d.get('meta'),
1236            rate_limit=d.get('rate_limit'),
1237        )
class AccountAttachmentDeleteResponse:
1240class AccountAttachmentDeleteResponse:
1241    '''
1242         AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
1243    '''
1244    __slots__ = [
1245        'meta',
1246        'rate_limit',
1247    ]
1248
1249    def __init__(
1250        self,
1251        meta=None,
1252        rate_limit=None,
1253    ):
1254        self.meta = meta if meta is not None else None
1255        '''
1256         Reserved for future use.
1257        '''
1258        self.rate_limit = rate_limit if rate_limit is not None else None
1259        '''
1260         Rate limit information.
1261        '''
1262
1263    def __repr__(self):
1264        return '<sdm.AccountAttachmentDeleteResponse ' + \
1265            'meta: ' + repr(self.meta) + ' ' +\
1266            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1267            '>'
1268
1269    def to_dict(self):
1270        return {
1271            'meta': self.meta,
1272            'rate_limit': self.rate_limit,
1273        }
1274
1275    @classmethod
1276    def from_dict(cls, d):
1277        return cls(
1278            meta=d.get('meta'),
1279            rate_limit=d.get('rate_limit'),
1280        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
1249    def __init__(
1250        self,
1251        meta=None,
1252        rate_limit=None,
1253    ):
1254        self.meta = meta if meta is not None else None
1255        '''
1256         Reserved for future use.
1257        '''
1258        self.rate_limit = rate_limit if rate_limit is not None else None
1259        '''
1260         Rate limit information.
1261        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1269    def to_dict(self):
1270        return {
1271            'meta': self.meta,
1272            'rate_limit': self.rate_limit,
1273        }
@classmethod
def from_dict(cls, d)
1275    @classmethod
1276    def from_dict(cls, d):
1277        return cls(
1278            meta=d.get('meta'),
1279            rate_limit=d.get('rate_limit'),
1280        )
class AccountAttachmentGetResponse:
1283class AccountAttachmentGetResponse:
1284    '''
1285         AccountAttachmentGetResponse returns a requested AccountAttachment.
1286    '''
1287    __slots__ = [
1288        'account_attachment',
1289        'meta',
1290        'rate_limit',
1291    ]
1292
1293    def __init__(
1294        self,
1295        account_attachment=None,
1296        meta=None,
1297        rate_limit=None,
1298    ):
1299        self.account_attachment = account_attachment if account_attachment is not None else None
1300        '''
1301         The requested AccountAttachment.
1302        '''
1303        self.meta = meta if meta is not None else None
1304        '''
1305         Reserved for future use.
1306        '''
1307        self.rate_limit = rate_limit if rate_limit is not None else None
1308        '''
1309         Rate limit information.
1310        '''
1311
1312    def __repr__(self):
1313        return '<sdm.AccountAttachmentGetResponse ' + \
1314            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1315            'meta: ' + repr(self.meta) + ' ' +\
1316            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1317            '>'
1318
1319    def to_dict(self):
1320        return {
1321            'account_attachment': self.account_attachment,
1322            'meta': self.meta,
1323            'rate_limit': self.rate_limit,
1324        }
1325
1326    @classmethod
1327    def from_dict(cls, d):
1328        return cls(
1329            account_attachment=d.get('account_attachment'),
1330            meta=d.get('meta'),
1331            rate_limit=d.get('rate_limit'),
1332        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
1293    def __init__(
1294        self,
1295        account_attachment=None,
1296        meta=None,
1297        rate_limit=None,
1298    ):
1299        self.account_attachment = account_attachment if account_attachment is not None else None
1300        '''
1301         The requested AccountAttachment.
1302        '''
1303        self.meta = meta if meta is not None else None
1304        '''
1305         Reserved for future use.
1306        '''
1307        self.rate_limit = rate_limit if rate_limit is not None else None
1308        '''
1309         Rate limit information.
1310        '''
account_attachment

The requested AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1319    def to_dict(self):
1320        return {
1321            'account_attachment': self.account_attachment,
1322            'meta': self.meta,
1323            'rate_limit': self.rate_limit,
1324        }
@classmethod
def from_dict(cls, d)
1326    @classmethod
1327    def from_dict(cls, d):
1328        return cls(
1329            account_attachment=d.get('account_attachment'),
1330            meta=d.get('meta'),
1331            rate_limit=d.get('rate_limit'),
1332        )
class AccountCreateResponse:
1335class AccountCreateResponse:
1336    '''
1337         AccountCreateResponse reports how the Accounts were created in the system.
1338    '''
1339    __slots__ = [
1340        'account',
1341        'meta',
1342        'rate_limit',
1343        'token',
1344    ]
1345
1346    def __init__(
1347        self,
1348        account=None,
1349        meta=None,
1350        rate_limit=None,
1351        token=None,
1352    ):
1353        self.account = account if account is not None else None
1354        '''
1355         The created Account.
1356        '''
1357        self.meta = meta if meta is not None else None
1358        '''
1359         Reserved for future use.
1360        '''
1361        self.rate_limit = rate_limit if rate_limit is not None else None
1362        '''
1363         Rate limit information.
1364        '''
1365        self.token = token if token is not None else ''
1366        '''
1367         The auth token generated for the Account. The Account will use this token to
1368         authenticate with the strongDM API.
1369        '''
1370
1371    def __repr__(self):
1372        return '<sdm.AccountCreateResponse ' + \
1373            'account: ' + repr(self.account) + ' ' +\
1374            'meta: ' + repr(self.meta) + ' ' +\
1375            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1376            'token: ' + repr(self.token) + ' ' +\
1377            '>'
1378
1379    def to_dict(self):
1380        return {
1381            'account': self.account,
1382            'meta': self.meta,
1383            'rate_limit': self.rate_limit,
1384            'token': self.token,
1385        }
1386
1387    @classmethod
1388    def from_dict(cls, d):
1389        return cls(
1390            account=d.get('account'),
1391            meta=d.get('meta'),
1392            rate_limit=d.get('rate_limit'),
1393            token=d.get('token'),
1394        )

AccountCreateResponse reports how the Accounts were created in the system.

AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
1346    def __init__(
1347        self,
1348        account=None,
1349        meta=None,
1350        rate_limit=None,
1351        token=None,
1352    ):
1353        self.account = account if account is not None else None
1354        '''
1355         The created Account.
1356        '''
1357        self.meta = meta if meta is not None else None
1358        '''
1359         Reserved for future use.
1360        '''
1361        self.rate_limit = rate_limit if rate_limit is not None else None
1362        '''
1363         Rate limit information.
1364        '''
1365        self.token = token if token is not None else ''
1366        '''
1367         The auth token generated for the Account. The Account will use this token to
1368         authenticate with the strongDM API.
1369        '''
account

The created Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

token

The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

def to_dict(self)
1379    def to_dict(self):
1380        return {
1381            'account': self.account,
1382            'meta': self.meta,
1383            'rate_limit': self.rate_limit,
1384            'token': self.token,
1385        }
@classmethod
def from_dict(cls, d)
1387    @classmethod
1388    def from_dict(cls, d):
1389        return cls(
1390            account=d.get('account'),
1391            meta=d.get('meta'),
1392            rate_limit=d.get('rate_limit'),
1393            token=d.get('token'),
1394        )
class AccountDeleteResponse:
1397class AccountDeleteResponse:
1398    '''
1399         AccountDeleteResponse returns information about a Account that was deleted.
1400    '''
1401    __slots__ = [
1402        'meta',
1403        'rate_limit',
1404    ]
1405
1406    def __init__(
1407        self,
1408        meta=None,
1409        rate_limit=None,
1410    ):
1411        self.meta = meta if meta is not None else None
1412        '''
1413         Reserved for future use.
1414        '''
1415        self.rate_limit = rate_limit if rate_limit is not None else None
1416        '''
1417         Rate limit information.
1418        '''
1419
1420    def __repr__(self):
1421        return '<sdm.AccountDeleteResponse ' + \
1422            'meta: ' + repr(self.meta) + ' ' +\
1423            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1424            '>'
1425
1426    def to_dict(self):
1427        return {
1428            'meta': self.meta,
1429            'rate_limit': self.rate_limit,
1430        }
1431
1432    @classmethod
1433    def from_dict(cls, d):
1434        return cls(
1435            meta=d.get('meta'),
1436            rate_limit=d.get('rate_limit'),
1437        )

AccountDeleteResponse returns information about a Account that was deleted.

AccountDeleteResponse(meta=None, rate_limit=None)
1406    def __init__(
1407        self,
1408        meta=None,
1409        rate_limit=None,
1410    ):
1411        self.meta = meta if meta is not None else None
1412        '''
1413         Reserved for future use.
1414        '''
1415        self.rate_limit = rate_limit if rate_limit is not None else None
1416        '''
1417         Rate limit information.
1418        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1426    def to_dict(self):
1427        return {
1428            'meta': self.meta,
1429            'rate_limit': self.rate_limit,
1430        }
@classmethod
def from_dict(cls, d)
1432    @classmethod
1433    def from_dict(cls, d):
1434        return cls(
1435            meta=d.get('meta'),
1436            rate_limit=d.get('rate_limit'),
1437        )
class AccountGetResponse:
1440class AccountGetResponse:
1441    '''
1442         AccountGetResponse returns a requested Account.
1443    '''
1444    __slots__ = [
1445        'account',
1446        'meta',
1447        'rate_limit',
1448    ]
1449
1450    def __init__(
1451        self,
1452        account=None,
1453        meta=None,
1454        rate_limit=None,
1455    ):
1456        self.account = account if account is not None else None
1457        '''
1458         The requested Account.
1459        '''
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
1468
1469    def __repr__(self):
1470        return '<sdm.AccountGetResponse ' + \
1471            'account: ' + repr(self.account) + ' ' +\
1472            'meta: ' + repr(self.meta) + ' ' +\
1473            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1474            '>'
1475
1476    def to_dict(self):
1477        return {
1478            'account': self.account,
1479            'meta': self.meta,
1480            'rate_limit': self.rate_limit,
1481        }
1482
1483    @classmethod
1484    def from_dict(cls, d):
1485        return cls(
1486            account=d.get('account'),
1487            meta=d.get('meta'),
1488            rate_limit=d.get('rate_limit'),
1489        )

AccountGetResponse returns a requested Account.

AccountGetResponse(account=None, meta=None, rate_limit=None)
1450    def __init__(
1451        self,
1452        account=None,
1453        meta=None,
1454        rate_limit=None,
1455    ):
1456        self.account = account if account is not None else None
1457        '''
1458         The requested Account.
1459        '''
1460        self.meta = meta if meta is not None else None
1461        '''
1462         Reserved for future use.
1463        '''
1464        self.rate_limit = rate_limit if rate_limit is not None else None
1465        '''
1466         Rate limit information.
1467        '''
account

The requested Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1476    def to_dict(self):
1477        return {
1478            'account': self.account,
1479            'meta': self.meta,
1480            'rate_limit': self.rate_limit,
1481        }
@classmethod
def from_dict(cls, d)
1483    @classmethod
1484    def from_dict(cls, d):
1485        return cls(
1486            account=d.get('account'),
1487            meta=d.get('meta'),
1488            rate_limit=d.get('rate_limit'),
1489        )
class AccountGrant:
1492class AccountGrant:
1493    '''
1494         AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
1495    '''
1496    __slots__ = [
1497        'account_id',
1498        'id',
1499        'resource_id',
1500        'start_from',
1501        'valid_until',
1502    ]
1503
1504    def __init__(
1505        self,
1506        account_id=None,
1507        id=None,
1508        resource_id=None,
1509        start_from=None,
1510        valid_until=None,
1511    ):
1512        self.account_id = account_id if account_id is not None else ''
1513        '''
1514         The account ID of this AccountGrant.
1515        '''
1516        self.id = id if id is not None else ''
1517        '''
1518         Unique identifier of the AccountGrant.
1519        '''
1520        self.resource_id = resource_id if resource_id is not None else ''
1521        '''
1522         The resource ID of this AccountGrant.
1523        '''
1524        self.start_from = start_from if start_from is not None else None
1525        '''
1526         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1527        '''
1528        self.valid_until = valid_until if valid_until is not None else None
1529        '''
1530         The timestamp when the resource grant will expire.
1531        '''
1532
1533    def __repr__(self):
1534        return '<sdm.AccountGrant ' + \
1535            'account_id: ' + repr(self.account_id) + ' ' +\
1536            'id: ' + repr(self.id) + ' ' +\
1537            'resource_id: ' + repr(self.resource_id) + ' ' +\
1538            'start_from: ' + repr(self.start_from) + ' ' +\
1539            'valid_until: ' + repr(self.valid_until) + ' ' +\
1540            '>'
1541
1542    def to_dict(self):
1543        return {
1544            'account_id': self.account_id,
1545            'id': self.id,
1546            'resource_id': self.resource_id,
1547            'start_from': self.start_from,
1548            'valid_until': self.valid_until,
1549        }
1550
1551    @classmethod
1552    def from_dict(cls, d):
1553        return cls(
1554            account_id=d.get('account_id'),
1555            id=d.get('id'),
1556            resource_id=d.get('resource_id'),
1557            start_from=d.get('start_from'),
1558            valid_until=d.get('valid_until'),
1559        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None)
1504    def __init__(
1505        self,
1506        account_id=None,
1507        id=None,
1508        resource_id=None,
1509        start_from=None,
1510        valid_until=None,
1511    ):
1512        self.account_id = account_id if account_id is not None else ''
1513        '''
1514         The account ID of this AccountGrant.
1515        '''
1516        self.id = id if id is not None else ''
1517        '''
1518         Unique identifier of the AccountGrant.
1519        '''
1520        self.resource_id = resource_id if resource_id is not None else ''
1521        '''
1522         The resource ID of this AccountGrant.
1523        '''
1524        self.start_from = start_from if start_from is not None else None
1525        '''
1526         The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.
1527        '''
1528        self.valid_until = valid_until if valid_until is not None else None
1529        '''
1530         The timestamp when the resource grant will expire.
1531        '''
account_id

The account ID of this AccountGrant.

id

Unique identifier of the AccountGrant.

resource_id

The resource ID of this AccountGrant.

start_from

The timestamp when the resource will be granted. When creating an AccountGrant, if this field is not specified, it will default to the current time.

valid_until

The timestamp when the resource grant will expire.

def to_dict(self)
1542    def to_dict(self):
1543        return {
1544            'account_id': self.account_id,
1545            'id': self.id,
1546            'resource_id': self.resource_id,
1547            'start_from': self.start_from,
1548            'valid_until': self.valid_until,
1549        }
@classmethod
def from_dict(cls, d)
1551    @classmethod
1552    def from_dict(cls, d):
1553        return cls(
1554            account_id=d.get('account_id'),
1555            id=d.get('id'),
1556            resource_id=d.get('resource_id'),
1557            start_from=d.get('start_from'),
1558            valid_until=d.get('valid_until'),
1559        )
class AccountGrantCreateResponse:
1562class AccountGrantCreateResponse:
1563    '''
1564         AccountGrantCreateResponse reports how the AccountGrants were created in the system.
1565    '''
1566    __slots__ = [
1567        'account_grant',
1568        'meta',
1569        'rate_limit',
1570    ]
1571
1572    def __init__(
1573        self,
1574        account_grant=None,
1575        meta=None,
1576        rate_limit=None,
1577    ):
1578        self.account_grant = account_grant if account_grant is not None else None
1579        '''
1580         The created AccountGrant.
1581        '''
1582        self.meta = meta if meta is not None else None
1583        '''
1584         Reserved for future use.
1585        '''
1586        self.rate_limit = rate_limit if rate_limit is not None else None
1587        '''
1588         Rate limit information.
1589        '''
1590
1591    def __repr__(self):
1592        return '<sdm.AccountGrantCreateResponse ' + \
1593            'account_grant: ' + repr(self.account_grant) + ' ' +\
1594            'meta: ' + repr(self.meta) + ' ' +\
1595            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1596            '>'
1597
1598    def to_dict(self):
1599        return {
1600            'account_grant': self.account_grant,
1601            'meta': self.meta,
1602            'rate_limit': self.rate_limit,
1603        }
1604
1605    @classmethod
1606    def from_dict(cls, d):
1607        return cls(
1608            account_grant=d.get('account_grant'),
1609            meta=d.get('meta'),
1610            rate_limit=d.get('rate_limit'),
1611        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
1572    def __init__(
1573        self,
1574        account_grant=None,
1575        meta=None,
1576        rate_limit=None,
1577    ):
1578        self.account_grant = account_grant if account_grant is not None else None
1579        '''
1580         The created AccountGrant.
1581        '''
1582        self.meta = meta if meta is not None else None
1583        '''
1584         Reserved for future use.
1585        '''
1586        self.rate_limit = rate_limit if rate_limit is not None else None
1587        '''
1588         Rate limit information.
1589        '''
account_grant

The created AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1598    def to_dict(self):
1599        return {
1600            'account_grant': self.account_grant,
1601            'meta': self.meta,
1602            'rate_limit': self.rate_limit,
1603        }
@classmethod
def from_dict(cls, d)
1605    @classmethod
1606    def from_dict(cls, d):
1607        return cls(
1608            account_grant=d.get('account_grant'),
1609            meta=d.get('meta'),
1610            rate_limit=d.get('rate_limit'),
1611        )
class AccountGrantDeleteResponse:
1614class AccountGrantDeleteResponse:
1615    '''
1616         AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
1617    '''
1618    __slots__ = [
1619        'meta',
1620        'rate_limit',
1621    ]
1622
1623    def __init__(
1624        self,
1625        meta=None,
1626        rate_limit=None,
1627    ):
1628        self.meta = meta if meta is not None else None
1629        '''
1630         Reserved for future use.
1631        '''
1632        self.rate_limit = rate_limit if rate_limit is not None else None
1633        '''
1634         Rate limit information.
1635        '''
1636
1637    def __repr__(self):
1638        return '<sdm.AccountGrantDeleteResponse ' + \
1639            'meta: ' + repr(self.meta) + ' ' +\
1640            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1641            '>'
1642
1643    def to_dict(self):
1644        return {
1645            'meta': self.meta,
1646            'rate_limit': self.rate_limit,
1647        }
1648
1649    @classmethod
1650    def from_dict(cls, d):
1651        return cls(
1652            meta=d.get('meta'),
1653            rate_limit=d.get('rate_limit'),
1654        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

AccountGrantDeleteResponse(meta=None, rate_limit=None)
1623    def __init__(
1624        self,
1625        meta=None,
1626        rate_limit=None,
1627    ):
1628        self.meta = meta if meta is not None else None
1629        '''
1630         Reserved for future use.
1631        '''
1632        self.rate_limit = rate_limit if rate_limit is not None else None
1633        '''
1634         Rate limit information.
1635        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1643    def to_dict(self):
1644        return {
1645            'meta': self.meta,
1646            'rate_limit': self.rate_limit,
1647        }
@classmethod
def from_dict(cls, d)
1649    @classmethod
1650    def from_dict(cls, d):
1651        return cls(
1652            meta=d.get('meta'),
1653            rate_limit=d.get('rate_limit'),
1654        )
class AccountGrantGetResponse:
1657class AccountGrantGetResponse:
1658    '''
1659         AccountGrantGetResponse returns a requested AccountGrant.
1660    '''
1661    __slots__ = [
1662        'account_grant',
1663        'meta',
1664        'rate_limit',
1665    ]
1666
1667    def __init__(
1668        self,
1669        account_grant=None,
1670        meta=None,
1671        rate_limit=None,
1672    ):
1673        self.account_grant = account_grant if account_grant is not None else None
1674        '''
1675         The requested AccountGrant.
1676        '''
1677        self.meta = meta if meta is not None else None
1678        '''
1679         Reserved for future use.
1680        '''
1681        self.rate_limit = rate_limit if rate_limit is not None else None
1682        '''
1683         Rate limit information.
1684        '''
1685
1686    def __repr__(self):
1687        return '<sdm.AccountGrantGetResponse ' + \
1688            'account_grant: ' + repr(self.account_grant) + ' ' +\
1689            'meta: ' + repr(self.meta) + ' ' +\
1690            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1691            '>'
1692
1693    def to_dict(self):
1694        return {
1695            'account_grant': self.account_grant,
1696            'meta': self.meta,
1697            'rate_limit': self.rate_limit,
1698        }
1699
1700    @classmethod
1701    def from_dict(cls, d):
1702        return cls(
1703            account_grant=d.get('account_grant'),
1704            meta=d.get('meta'),
1705            rate_limit=d.get('rate_limit'),
1706        )

AccountGrantGetResponse returns a requested AccountGrant.

AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
1667    def __init__(
1668        self,
1669        account_grant=None,
1670        meta=None,
1671        rate_limit=None,
1672    ):
1673        self.account_grant = account_grant if account_grant is not None else None
1674        '''
1675         The requested AccountGrant.
1676        '''
1677        self.meta = meta if meta is not None else None
1678        '''
1679         Reserved for future use.
1680        '''
1681        self.rate_limit = rate_limit if rate_limit is not None else None
1682        '''
1683         Rate limit information.
1684        '''
account_grant

The requested AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1693    def to_dict(self):
1694        return {
1695            'account_grant': self.account_grant,
1696            'meta': self.meta,
1697            'rate_limit': self.rate_limit,
1698        }
@classmethod
def from_dict(cls, d)
1700    @classmethod
1701    def from_dict(cls, d):
1702        return cls(
1703            account_grant=d.get('account_grant'),
1704            meta=d.get('meta'),
1705            rate_limit=d.get('rate_limit'),
1706        )
class AccountUpdateResponse:
1709class AccountUpdateResponse:
1710    '''
1711         AccountUpdateResponse returns the fields of a Account after it has been updated by
1712     a AccountUpdateRequest.
1713    '''
1714    __slots__ = [
1715        'account',
1716        'meta',
1717        'rate_limit',
1718    ]
1719
1720    def __init__(
1721        self,
1722        account=None,
1723        meta=None,
1724        rate_limit=None,
1725    ):
1726        self.account = account if account is not None else None
1727        '''
1728         The updated Account.
1729        '''
1730        self.meta = meta if meta is not None else None
1731        '''
1732         Reserved for future use.
1733        '''
1734        self.rate_limit = rate_limit if rate_limit is not None else None
1735        '''
1736         Rate limit information.
1737        '''
1738
1739    def __repr__(self):
1740        return '<sdm.AccountUpdateResponse ' + \
1741            'account: ' + repr(self.account) + ' ' +\
1742            'meta: ' + repr(self.meta) + ' ' +\
1743            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1744            '>'
1745
1746    def to_dict(self):
1747        return {
1748            'account': self.account,
1749            'meta': self.meta,
1750            'rate_limit': self.rate_limit,
1751        }
1752
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            account=d.get('account'),
1757            meta=d.get('meta'),
1758            rate_limit=d.get('rate_limit'),
1759        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

AccountUpdateResponse(account=None, meta=None, rate_limit=None)
1720    def __init__(
1721        self,
1722        account=None,
1723        meta=None,
1724        rate_limit=None,
1725    ):
1726        self.account = account if account is not None else None
1727        '''
1728         The updated Account.
1729        '''
1730        self.meta = meta if meta is not None else None
1731        '''
1732         Reserved for future use.
1733        '''
1734        self.rate_limit = rate_limit if rate_limit is not None else None
1735        '''
1736         Rate limit information.
1737        '''
account

The updated Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1746    def to_dict(self):
1747        return {
1748            'account': self.account,
1749            'meta': self.meta,
1750            'rate_limit': self.rate_limit,
1751        }
@classmethod
def from_dict(cls, d)
1753    @classmethod
1754    def from_dict(cls, d):
1755        return cls(
1756            account=d.get('account'),
1757            meta=d.get('meta'),
1758            rate_limit=d.get('rate_limit'),
1759        )
class AmazonEKS:
1762class AmazonEKS:
1763    __slots__ = [
1764        'access_key',
1765        'bind_interface',
1766        'certificate_authority',
1767        'cluster_name',
1768        'egress_filter',
1769        'endpoint',
1770        'healthcheck_namespace',
1771        'healthy',
1772        'id',
1773        'name',
1774        'region',
1775        'remote_identity_group_id',
1776        'remote_identity_healthcheck_username',
1777        'role_arn',
1778        'role_external_id',
1779        'secret_access_key',
1780        'secret_store_id',
1781        'tags',
1782    ]
1783
1784    def __init__(
1785        self,
1786        access_key=None,
1787        bind_interface=None,
1788        certificate_authority=None,
1789        cluster_name=None,
1790        egress_filter=None,
1791        endpoint=None,
1792        healthcheck_namespace=None,
1793        healthy=None,
1794        id=None,
1795        name=None,
1796        region=None,
1797        remote_identity_group_id=None,
1798        remote_identity_healthcheck_username=None,
1799        role_arn=None,
1800        role_external_id=None,
1801        secret_access_key=None,
1802        secret_store_id=None,
1803        tags=None,
1804    ):
1805        self.access_key = access_key if access_key is not None else ''
1806        self.bind_interface = bind_interface if bind_interface is not None else ''
1807        '''
1808         Bind interface
1809        '''
1810        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1811        self.cluster_name = cluster_name if cluster_name is not None else ''
1812        self.egress_filter = egress_filter if egress_filter is not None else ''
1813        '''
1814         A filter applied to the routing logic to pin datasource to nodes.
1815        '''
1816        self.endpoint = endpoint if endpoint is not None else ''
1817        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1818        '''
1819         The path used to check the health of your connection.  Defaults to `default`.
1820        '''
1821        self.healthy = healthy if healthy is not None else False
1822        '''
1823         True if the datasource is reachable and the credentials are valid.
1824        '''
1825        self.id = id if id is not None else ''
1826        '''
1827         Unique identifier of the Resource.
1828        '''
1829        self.name = name if name is not None else ''
1830        '''
1831         Unique human-readable name of the Resource.
1832        '''
1833        self.region = region if region is not None else ''
1834        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1835        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1836        self.role_arn = role_arn if role_arn is not None else ''
1837        self.role_external_id = role_external_id if role_external_id is not None else ''
1838        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1840        '''
1841         ID of the secret store containing credentials for this resource, if any.
1842        '''
1843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1844        '''
1845         Tags is a map of key, value pairs.
1846        '''
1847
1848    def __repr__(self):
1849        return '<sdm.AmazonEKS ' + \
1850            'access_key: ' + repr(self.access_key) + ' ' +\
1851            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1852            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1853            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1854            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1855            'endpoint: ' + repr(self.endpoint) + ' ' +\
1856            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1857            'healthy: ' + repr(self.healthy) + ' ' +\
1858            'id: ' + repr(self.id) + ' ' +\
1859            'name: ' + repr(self.name) + ' ' +\
1860            'region: ' + repr(self.region) + ' ' +\
1861            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1862            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1863            'role_arn: ' + repr(self.role_arn) + ' ' +\
1864            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1865            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1866            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1867            'tags: ' + repr(self.tags) + ' ' +\
1868            '>'
1869
1870    def to_dict(self):
1871        return {
1872            'access_key': self.access_key,
1873            'bind_interface': self.bind_interface,
1874            'certificate_authority': self.certificate_authority,
1875            'cluster_name': self.cluster_name,
1876            'egress_filter': self.egress_filter,
1877            'endpoint': self.endpoint,
1878            'healthcheck_namespace': self.healthcheck_namespace,
1879            'healthy': self.healthy,
1880            'id': self.id,
1881            'name': self.name,
1882            'region': self.region,
1883            'remote_identity_group_id': self.remote_identity_group_id,
1884            'remote_identity_healthcheck_username':
1885            self.remote_identity_healthcheck_username,
1886            'role_arn': self.role_arn,
1887            'role_external_id': self.role_external_id,
1888            'secret_access_key': self.secret_access_key,
1889            'secret_store_id': self.secret_store_id,
1890            'tags': self.tags,
1891        }
1892
1893    @classmethod
1894    def from_dict(cls, d):
1895        return cls(
1896            access_key=d.get('access_key'),
1897            bind_interface=d.get('bind_interface'),
1898            certificate_authority=d.get('certificate_authority'),
1899            cluster_name=d.get('cluster_name'),
1900            egress_filter=d.get('egress_filter'),
1901            endpoint=d.get('endpoint'),
1902            healthcheck_namespace=d.get('healthcheck_namespace'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            region=d.get('region'),
1907            remote_identity_group_id=d.get('remote_identity_group_id'),
1908            remote_identity_healthcheck_username=d.get(
1909                'remote_identity_healthcheck_username'),
1910            role_arn=d.get('role_arn'),
1911            role_external_id=d.get('role_external_id'),
1912            secret_access_key=d.get('secret_access_key'),
1913            secret_store_id=d.get('secret_store_id'),
1914            tags=d.get('tags'),
1915        )
AmazonEKS( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1784    def __init__(
1785        self,
1786        access_key=None,
1787        bind_interface=None,
1788        certificate_authority=None,
1789        cluster_name=None,
1790        egress_filter=None,
1791        endpoint=None,
1792        healthcheck_namespace=None,
1793        healthy=None,
1794        id=None,
1795        name=None,
1796        region=None,
1797        remote_identity_group_id=None,
1798        remote_identity_healthcheck_username=None,
1799        role_arn=None,
1800        role_external_id=None,
1801        secret_access_key=None,
1802        secret_store_id=None,
1803        tags=None,
1804    ):
1805        self.access_key = access_key if access_key is not None else ''
1806        self.bind_interface = bind_interface if bind_interface is not None else ''
1807        '''
1808         Bind interface
1809        '''
1810        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1811        self.cluster_name = cluster_name if cluster_name is not None else ''
1812        self.egress_filter = egress_filter if egress_filter is not None else ''
1813        '''
1814         A filter applied to the routing logic to pin datasource to nodes.
1815        '''
1816        self.endpoint = endpoint if endpoint is not None else ''
1817        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1818        '''
1819         The path used to check the health of your connection.  Defaults to `default`.
1820        '''
1821        self.healthy = healthy if healthy is not None else False
1822        '''
1823         True if the datasource is reachable and the credentials are valid.
1824        '''
1825        self.id = id if id is not None else ''
1826        '''
1827         Unique identifier of the Resource.
1828        '''
1829        self.name = name if name is not None else ''
1830        '''
1831         Unique human-readable name of the Resource.
1832        '''
1833        self.region = region if region is not None else ''
1834        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1835        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1836        self.role_arn = role_arn if role_arn is not None else ''
1837        self.role_external_id = role_external_id if role_external_id is not None else ''
1838        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1839        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1840        '''
1841         ID of the secret store containing credentials for this resource, if any.
1842        '''
1843        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1844        '''
1845         Tags is a map of key, value pairs.
1846        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1870    def to_dict(self):
1871        return {
1872            'access_key': self.access_key,
1873            'bind_interface': self.bind_interface,
1874            'certificate_authority': self.certificate_authority,
1875            'cluster_name': self.cluster_name,
1876            'egress_filter': self.egress_filter,
1877            'endpoint': self.endpoint,
1878            'healthcheck_namespace': self.healthcheck_namespace,
1879            'healthy': self.healthy,
1880            'id': self.id,
1881            'name': self.name,
1882            'region': self.region,
1883            'remote_identity_group_id': self.remote_identity_group_id,
1884            'remote_identity_healthcheck_username':
1885            self.remote_identity_healthcheck_username,
1886            'role_arn': self.role_arn,
1887            'role_external_id': self.role_external_id,
1888            'secret_access_key': self.secret_access_key,
1889            'secret_store_id': self.secret_store_id,
1890            'tags': self.tags,
1891        }
@classmethod
def from_dict(cls, d)
1893    @classmethod
1894    def from_dict(cls, d):
1895        return cls(
1896            access_key=d.get('access_key'),
1897            bind_interface=d.get('bind_interface'),
1898            certificate_authority=d.get('certificate_authority'),
1899            cluster_name=d.get('cluster_name'),
1900            egress_filter=d.get('egress_filter'),
1901            endpoint=d.get('endpoint'),
1902            healthcheck_namespace=d.get('healthcheck_namespace'),
1903            healthy=d.get('healthy'),
1904            id=d.get('id'),
1905            name=d.get('name'),
1906            region=d.get('region'),
1907            remote_identity_group_id=d.get('remote_identity_group_id'),
1908            remote_identity_healthcheck_username=d.get(
1909                'remote_identity_healthcheck_username'),
1910            role_arn=d.get('role_arn'),
1911            role_external_id=d.get('role_external_id'),
1912            secret_access_key=d.get('secret_access_key'),
1913            secret_store_id=d.get('secret_store_id'),
1914            tags=d.get('tags'),
1915        )
class AmazonEKSUserImpersonation:
1918class AmazonEKSUserImpersonation:
1919    __slots__ = [
1920        'access_key',
1921        'bind_interface',
1922        'certificate_authority',
1923        'cluster_name',
1924        'egress_filter',
1925        'endpoint',
1926        'healthcheck_namespace',
1927        'healthy',
1928        'id',
1929        'name',
1930        'region',
1931        'role_arn',
1932        'role_external_id',
1933        'secret_access_key',
1934        'secret_store_id',
1935        'tags',
1936    ]
1937
1938    def __init__(
1939        self,
1940        access_key=None,
1941        bind_interface=None,
1942        certificate_authority=None,
1943        cluster_name=None,
1944        egress_filter=None,
1945        endpoint=None,
1946        healthcheck_namespace=None,
1947        healthy=None,
1948        id=None,
1949        name=None,
1950        region=None,
1951        role_arn=None,
1952        role_external_id=None,
1953        secret_access_key=None,
1954        secret_store_id=None,
1955        tags=None,
1956    ):
1957        self.access_key = access_key if access_key is not None else ''
1958        self.bind_interface = bind_interface if bind_interface is not None else ''
1959        '''
1960         Bind interface
1961        '''
1962        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1963        self.cluster_name = cluster_name if cluster_name is not None else ''
1964        self.egress_filter = egress_filter if egress_filter is not None else ''
1965        '''
1966         A filter applied to the routing logic to pin datasource to nodes.
1967        '''
1968        self.endpoint = endpoint if endpoint is not None else ''
1969        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1970        '''
1971         The path used to check the health of your connection.  Defaults to `default`.
1972        '''
1973        self.healthy = healthy if healthy is not None else False
1974        '''
1975         True if the datasource is reachable and the credentials are valid.
1976        '''
1977        self.id = id if id is not None else ''
1978        '''
1979         Unique identifier of the Resource.
1980        '''
1981        self.name = name if name is not None else ''
1982        '''
1983         Unique human-readable name of the Resource.
1984        '''
1985        self.region = region if region is not None else ''
1986        self.role_arn = role_arn if role_arn is not None else ''
1987        self.role_external_id = role_external_id if role_external_id is not None else ''
1988        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1989        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1990        '''
1991         ID of the secret store containing credentials for this resource, if any.
1992        '''
1993        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1994        '''
1995         Tags is a map of key, value pairs.
1996        '''
1997
1998    def __repr__(self):
1999        return '<sdm.AmazonEKSUserImpersonation ' + \
2000            'access_key: ' + repr(self.access_key) + ' ' +\
2001            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2002            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
2003            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
2004            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2005            'endpoint: ' + repr(self.endpoint) + ' ' +\
2006            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
2007            'healthy: ' + repr(self.healthy) + ' ' +\
2008            'id: ' + repr(self.id) + ' ' +\
2009            'name: ' + repr(self.name) + ' ' +\
2010            'region: ' + repr(self.region) + ' ' +\
2011            'role_arn: ' + repr(self.role_arn) + ' ' +\
2012            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2013            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2014            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2015            'tags: ' + repr(self.tags) + ' ' +\
2016            '>'
2017
2018    def to_dict(self):
2019        return {
2020            'access_key': self.access_key,
2021            'bind_interface': self.bind_interface,
2022            'certificate_authority': self.certificate_authority,
2023            'cluster_name': self.cluster_name,
2024            'egress_filter': self.egress_filter,
2025            'endpoint': self.endpoint,
2026            'healthcheck_namespace': self.healthcheck_namespace,
2027            'healthy': self.healthy,
2028            'id': self.id,
2029            'name': self.name,
2030            'region': self.region,
2031            'role_arn': self.role_arn,
2032            'role_external_id': self.role_external_id,
2033            'secret_access_key': self.secret_access_key,
2034            'secret_store_id': self.secret_store_id,
2035            'tags': self.tags,
2036        }
2037
2038    @classmethod
2039    def from_dict(cls, d):
2040        return cls(
2041            access_key=d.get('access_key'),
2042            bind_interface=d.get('bind_interface'),
2043            certificate_authority=d.get('certificate_authority'),
2044            cluster_name=d.get('cluster_name'),
2045            egress_filter=d.get('egress_filter'),
2046            endpoint=d.get('endpoint'),
2047            healthcheck_namespace=d.get('healthcheck_namespace'),
2048            healthy=d.get('healthy'),
2049            id=d.get('id'),
2050            name=d.get('name'),
2051            region=d.get('region'),
2052            role_arn=d.get('role_arn'),
2053            role_external_id=d.get('role_external_id'),
2054            secret_access_key=d.get('secret_access_key'),
2055            secret_store_id=d.get('secret_store_id'),
2056            tags=d.get('tags'),
2057        )
AmazonEKSUserImpersonation( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1938    def __init__(
1939        self,
1940        access_key=None,
1941        bind_interface=None,
1942        certificate_authority=None,
1943        cluster_name=None,
1944        egress_filter=None,
1945        endpoint=None,
1946        healthcheck_namespace=None,
1947        healthy=None,
1948        id=None,
1949        name=None,
1950        region=None,
1951        role_arn=None,
1952        role_external_id=None,
1953        secret_access_key=None,
1954        secret_store_id=None,
1955        tags=None,
1956    ):
1957        self.access_key = access_key if access_key is not None else ''
1958        self.bind_interface = bind_interface if bind_interface is not None else ''
1959        '''
1960         Bind interface
1961        '''
1962        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1963        self.cluster_name = cluster_name if cluster_name is not None else ''
1964        self.egress_filter = egress_filter if egress_filter is not None else ''
1965        '''
1966         A filter applied to the routing logic to pin datasource to nodes.
1967        '''
1968        self.endpoint = endpoint if endpoint is not None else ''
1969        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1970        '''
1971         The path used to check the health of your connection.  Defaults to `default`.
1972        '''
1973        self.healthy = healthy if healthy is not None else False
1974        '''
1975         True if the datasource is reachable and the credentials are valid.
1976        '''
1977        self.id = id if id is not None else ''
1978        '''
1979         Unique identifier of the Resource.
1980        '''
1981        self.name = name if name is not None else ''
1982        '''
1983         Unique human-readable name of the Resource.
1984        '''
1985        self.region = region if region is not None else ''
1986        self.role_arn = role_arn if role_arn is not None else ''
1987        self.role_external_id = role_external_id if role_external_id is not None else ''
1988        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1989        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1990        '''
1991         ID of the secret store containing credentials for this resource, if any.
1992        '''
1993        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1994        '''
1995         Tags is a map of key, value pairs.
1996        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2018    def to_dict(self):
2019        return {
2020            'access_key': self.access_key,
2021            'bind_interface': self.bind_interface,
2022            'certificate_authority': self.certificate_authority,
2023            'cluster_name': self.cluster_name,
2024            'egress_filter': self.egress_filter,
2025            'endpoint': self.endpoint,
2026            'healthcheck_namespace': self.healthcheck_namespace,
2027            'healthy': self.healthy,
2028            'id': self.id,
2029            'name': self.name,
2030            'region': self.region,
2031            'role_arn': self.role_arn,
2032            'role_external_id': self.role_external_id,
2033            'secret_access_key': self.secret_access_key,
2034            'secret_store_id': self.secret_store_id,
2035            'tags': self.tags,
2036        }
@classmethod
def from_dict(cls, d)
2038    @classmethod
2039    def from_dict(cls, d):
2040        return cls(
2041            access_key=d.get('access_key'),
2042            bind_interface=d.get('bind_interface'),
2043            certificate_authority=d.get('certificate_authority'),
2044            cluster_name=d.get('cluster_name'),
2045            egress_filter=d.get('egress_filter'),
2046            endpoint=d.get('endpoint'),
2047            healthcheck_namespace=d.get('healthcheck_namespace'),
2048            healthy=d.get('healthy'),
2049            id=d.get('id'),
2050            name=d.get('name'),
2051            region=d.get('region'),
2052            role_arn=d.get('role_arn'),
2053            role_external_id=d.get('role_external_id'),
2054            secret_access_key=d.get('secret_access_key'),
2055            secret_store_id=d.get('secret_store_id'),
2056            tags=d.get('tags'),
2057        )
class AmazonES:
2060class AmazonES:
2061    __slots__ = [
2062        'access_key',
2063        'bind_interface',
2064        'egress_filter',
2065        'endpoint',
2066        'healthy',
2067        'id',
2068        'name',
2069        'port_override',
2070        'region',
2071        'role_arn',
2072        'role_external_id',
2073        'secret_access_key',
2074        'secret_store_id',
2075        'tags',
2076    ]
2077
2078    def __init__(
2079        self,
2080        access_key=None,
2081        bind_interface=None,
2082        egress_filter=None,
2083        endpoint=None,
2084        healthy=None,
2085        id=None,
2086        name=None,
2087        port_override=None,
2088        region=None,
2089        role_arn=None,
2090        role_external_id=None,
2091        secret_access_key=None,
2092        secret_store_id=None,
2093        tags=None,
2094    ):
2095        self.access_key = access_key if access_key is not None else ''
2096        self.bind_interface = bind_interface if bind_interface is not None else ''
2097        '''
2098         Bind interface
2099        '''
2100        self.egress_filter = egress_filter if egress_filter is not None else ''
2101        '''
2102         A filter applied to the routing logic to pin datasource to nodes.
2103        '''
2104        self.endpoint = endpoint if endpoint is not None else ''
2105        self.healthy = healthy if healthy is not None else False
2106        '''
2107         True if the datasource is reachable and the credentials are valid.
2108        '''
2109        self.id = id if id is not None else ''
2110        '''
2111         Unique identifier of the Resource.
2112        '''
2113        self.name = name if name is not None else ''
2114        '''
2115         Unique human-readable name of the Resource.
2116        '''
2117        self.port_override = port_override if port_override is not None else 0
2118        self.region = region if region is not None else ''
2119        self.role_arn = role_arn if role_arn is not None else ''
2120        self.role_external_id = role_external_id if role_external_id is not None else ''
2121        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2122        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2123        '''
2124         ID of the secret store containing credentials for this resource, if any.
2125        '''
2126        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2127        '''
2128         Tags is a map of key, value pairs.
2129        '''
2130
2131    def __repr__(self):
2132        return '<sdm.AmazonES ' + \
2133            'access_key: ' + repr(self.access_key) + ' ' +\
2134            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2135            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2136            'endpoint: ' + repr(self.endpoint) + ' ' +\
2137            'healthy: ' + repr(self.healthy) + ' ' +\
2138            'id: ' + repr(self.id) + ' ' +\
2139            'name: ' + repr(self.name) + ' ' +\
2140            'port_override: ' + repr(self.port_override) + ' ' +\
2141            'region: ' + repr(self.region) + ' ' +\
2142            'role_arn: ' + repr(self.role_arn) + ' ' +\
2143            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2144            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2145            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2146            'tags: ' + repr(self.tags) + ' ' +\
2147            '>'
2148
2149    def to_dict(self):
2150        return {
2151            'access_key': self.access_key,
2152            'bind_interface': self.bind_interface,
2153            'egress_filter': self.egress_filter,
2154            'endpoint': self.endpoint,
2155            'healthy': self.healthy,
2156            'id': self.id,
2157            'name': self.name,
2158            'port_override': self.port_override,
2159            'region': self.region,
2160            'role_arn': self.role_arn,
2161            'role_external_id': self.role_external_id,
2162            'secret_access_key': self.secret_access_key,
2163            'secret_store_id': self.secret_store_id,
2164            'tags': self.tags,
2165        }
2166
2167    @classmethod
2168    def from_dict(cls, d):
2169        return cls(
2170            access_key=d.get('access_key'),
2171            bind_interface=d.get('bind_interface'),
2172            egress_filter=d.get('egress_filter'),
2173            endpoint=d.get('endpoint'),
2174            healthy=d.get('healthy'),
2175            id=d.get('id'),
2176            name=d.get('name'),
2177            port_override=d.get('port_override'),
2178            region=d.get('region'),
2179            role_arn=d.get('role_arn'),
2180            role_external_id=d.get('role_external_id'),
2181            secret_access_key=d.get('secret_access_key'),
2182            secret_store_id=d.get('secret_store_id'),
2183            tags=d.get('tags'),
2184        )
AmazonES( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2078    def __init__(
2079        self,
2080        access_key=None,
2081        bind_interface=None,
2082        egress_filter=None,
2083        endpoint=None,
2084        healthy=None,
2085        id=None,
2086        name=None,
2087        port_override=None,
2088        region=None,
2089        role_arn=None,
2090        role_external_id=None,
2091        secret_access_key=None,
2092        secret_store_id=None,
2093        tags=None,
2094    ):
2095        self.access_key = access_key if access_key is not None else ''
2096        self.bind_interface = bind_interface if bind_interface is not None else ''
2097        '''
2098         Bind interface
2099        '''
2100        self.egress_filter = egress_filter if egress_filter is not None else ''
2101        '''
2102         A filter applied to the routing logic to pin datasource to nodes.
2103        '''
2104        self.endpoint = endpoint if endpoint is not None else ''
2105        self.healthy = healthy if healthy is not None else False
2106        '''
2107         True if the datasource is reachable and the credentials are valid.
2108        '''
2109        self.id = id if id is not None else ''
2110        '''
2111         Unique identifier of the Resource.
2112        '''
2113        self.name = name if name is not None else ''
2114        '''
2115         Unique human-readable name of the Resource.
2116        '''
2117        self.port_override = port_override if port_override is not None else 0
2118        self.region = region if region is not None else ''
2119        self.role_arn = role_arn if role_arn is not None else ''
2120        self.role_external_id = role_external_id if role_external_id is not None else ''
2121        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2122        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2123        '''
2124         ID of the secret store containing credentials for this resource, if any.
2125        '''
2126        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2127        '''
2128         Tags is a map of key, value pairs.
2129        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2149    def to_dict(self):
2150        return {
2151            'access_key': self.access_key,
2152            'bind_interface': self.bind_interface,
2153            'egress_filter': self.egress_filter,
2154            'endpoint': self.endpoint,
2155            'healthy': self.healthy,
2156            'id': self.id,
2157            'name': self.name,
2158            'port_override': self.port_override,
2159            'region': self.region,
2160            'role_arn': self.role_arn,
2161            'role_external_id': self.role_external_id,
2162            'secret_access_key': self.secret_access_key,
2163            'secret_store_id': self.secret_store_id,
2164            'tags': self.tags,
2165        }
@classmethod
def from_dict(cls, d)
2167    @classmethod
2168    def from_dict(cls, d):
2169        return cls(
2170            access_key=d.get('access_key'),
2171            bind_interface=d.get('bind_interface'),
2172            egress_filter=d.get('egress_filter'),
2173            endpoint=d.get('endpoint'),
2174            healthy=d.get('healthy'),
2175            id=d.get('id'),
2176            name=d.get('name'),
2177            port_override=d.get('port_override'),
2178            region=d.get('region'),
2179            role_arn=d.get('role_arn'),
2180            role_external_id=d.get('role_external_id'),
2181            secret_access_key=d.get('secret_access_key'),
2182            secret_store_id=d.get('secret_store_id'),
2183            tags=d.get('tags'),
2184        )
class AmazonMQAMQP091:
2187class AmazonMQAMQP091:
2188    __slots__ = [
2189        'bind_interface',
2190        'egress_filter',
2191        'healthy',
2192        'hostname',
2193        'id',
2194        'name',
2195        'password',
2196        'port',
2197        'port_override',
2198        'secret_store_id',
2199        'tags',
2200        'tls_required',
2201        'username',
2202    ]
2203
2204    def __init__(
2205        self,
2206        bind_interface=None,
2207        egress_filter=None,
2208        healthy=None,
2209        hostname=None,
2210        id=None,
2211        name=None,
2212        password=None,
2213        port=None,
2214        port_override=None,
2215        secret_store_id=None,
2216        tags=None,
2217        tls_required=None,
2218        username=None,
2219    ):
2220        self.bind_interface = bind_interface if bind_interface is not None else ''
2221        '''
2222         Bind interface
2223        '''
2224        self.egress_filter = egress_filter if egress_filter is not None else ''
2225        '''
2226         A filter applied to the routing logic to pin datasource to nodes.
2227        '''
2228        self.healthy = healthy if healthy is not None else False
2229        '''
2230         True if the datasource is reachable and the credentials are valid.
2231        '''
2232        self.hostname = hostname if hostname is not None else ''
2233        self.id = id if id is not None else ''
2234        '''
2235         Unique identifier of the Resource.
2236        '''
2237        self.name = name if name is not None else ''
2238        '''
2239         Unique human-readable name of the Resource.
2240        '''
2241        self.password = password if password is not None else ''
2242        self.port = port if port is not None else 0
2243        self.port_override = port_override if port_override is not None else 0
2244        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2245        '''
2246         ID of the secret store containing credentials for this resource, if any.
2247        '''
2248        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2249        '''
2250         Tags is a map of key, value pairs.
2251        '''
2252        self.tls_required = tls_required if tls_required is not None else False
2253        self.username = username if username is not None else ''
2254
2255    def __repr__(self):
2256        return '<sdm.AmazonMQAMQP091 ' + \
2257            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2258            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2259            'healthy: ' + repr(self.healthy) + ' ' +\
2260            'hostname: ' + repr(self.hostname) + ' ' +\
2261            'id: ' + repr(self.id) + ' ' +\
2262            'name: ' + repr(self.name) + ' ' +\
2263            'password: ' + repr(self.password) + ' ' +\
2264            'port: ' + repr(self.port) + ' ' +\
2265            'port_override: ' + repr(self.port_override) + ' ' +\
2266            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2267            'tags: ' + repr(self.tags) + ' ' +\
2268            'tls_required: ' + repr(self.tls_required) + ' ' +\
2269            'username: ' + repr(self.username) + ' ' +\
2270            '>'
2271
2272    def to_dict(self):
2273        return {
2274            'bind_interface': self.bind_interface,
2275            'egress_filter': self.egress_filter,
2276            'healthy': self.healthy,
2277            'hostname': self.hostname,
2278            'id': self.id,
2279            'name': self.name,
2280            'password': self.password,
2281            'port': self.port,
2282            'port_override': self.port_override,
2283            'secret_store_id': self.secret_store_id,
2284            'tags': self.tags,
2285            'tls_required': self.tls_required,
2286            'username': self.username,
2287        }
2288
2289    @classmethod
2290    def from_dict(cls, d):
2291        return cls(
2292            bind_interface=d.get('bind_interface'),
2293            egress_filter=d.get('egress_filter'),
2294            healthy=d.get('healthy'),
2295            hostname=d.get('hostname'),
2296            id=d.get('id'),
2297            name=d.get('name'),
2298            password=d.get('password'),
2299            port=d.get('port'),
2300            port_override=d.get('port_override'),
2301            secret_store_id=d.get('secret_store_id'),
2302            tags=d.get('tags'),
2303            tls_required=d.get('tls_required'),
2304            username=d.get('username'),
2305        )
AmazonMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
2204    def __init__(
2205        self,
2206        bind_interface=None,
2207        egress_filter=None,
2208        healthy=None,
2209        hostname=None,
2210        id=None,
2211        name=None,
2212        password=None,
2213        port=None,
2214        port_override=None,
2215        secret_store_id=None,
2216        tags=None,
2217        tls_required=None,
2218        username=None,
2219    ):
2220        self.bind_interface = bind_interface if bind_interface is not None else ''
2221        '''
2222         Bind interface
2223        '''
2224        self.egress_filter = egress_filter if egress_filter is not None else ''
2225        '''
2226         A filter applied to the routing logic to pin datasource to nodes.
2227        '''
2228        self.healthy = healthy if healthy is not None else False
2229        '''
2230         True if the datasource is reachable and the credentials are valid.
2231        '''
2232        self.hostname = hostname if hostname is not None else ''
2233        self.id = id if id is not None else ''
2234        '''
2235         Unique identifier of the Resource.
2236        '''
2237        self.name = name if name is not None else ''
2238        '''
2239         Unique human-readable name of the Resource.
2240        '''
2241        self.password = password if password is not None else ''
2242        self.port = port if port is not None else 0
2243        self.port_override = port_override if port_override is not None else 0
2244        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2245        '''
2246         ID of the secret store containing credentials for this resource, if any.
2247        '''
2248        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2249        '''
2250         Tags is a map of key, value pairs.
2251        '''
2252        self.tls_required = tls_required if tls_required is not None else False
2253        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
2272    def to_dict(self):
2273        return {
2274            'bind_interface': self.bind_interface,
2275            'egress_filter': self.egress_filter,
2276            'healthy': self.healthy,
2277            'hostname': self.hostname,
2278            'id': self.id,
2279            'name': self.name,
2280            'password': self.password,
2281            'port': self.port,
2282            'port_override': self.port_override,
2283            'secret_store_id': self.secret_store_id,
2284            'tags': self.tags,
2285            'tls_required': self.tls_required,
2286            'username': self.username,
2287        }
@classmethod
def from_dict(cls, d)
2289    @classmethod
2290    def from_dict(cls, d):
2291        return cls(
2292            bind_interface=d.get('bind_interface'),
2293            egress_filter=d.get('egress_filter'),
2294            healthy=d.get('healthy'),
2295            hostname=d.get('hostname'),
2296            id=d.get('id'),
2297            name=d.get('name'),
2298            password=d.get('password'),
2299            port=d.get('port'),
2300            port_override=d.get('port_override'),
2301            secret_store_id=d.get('secret_store_id'),
2302            tags=d.get('tags'),
2303            tls_required=d.get('tls_required'),
2304            username=d.get('username'),
2305        )
class Athena:
2308class Athena:
2309    __slots__ = [
2310        'access_key',
2311        'bind_interface',
2312        'egress_filter',
2313        'healthy',
2314        'id',
2315        'name',
2316        'output',
2317        'port_override',
2318        'region',
2319        'role_arn',
2320        'role_external_id',
2321        'secret_access_key',
2322        'secret_store_id',
2323        'tags',
2324    ]
2325
2326    def __init__(
2327        self,
2328        access_key=None,
2329        bind_interface=None,
2330        egress_filter=None,
2331        healthy=None,
2332        id=None,
2333        name=None,
2334        output=None,
2335        port_override=None,
2336        region=None,
2337        role_arn=None,
2338        role_external_id=None,
2339        secret_access_key=None,
2340        secret_store_id=None,
2341        tags=None,
2342    ):
2343        self.access_key = access_key if access_key is not None else ''
2344        self.bind_interface = bind_interface if bind_interface is not None else ''
2345        '''
2346         Bind interface
2347        '''
2348        self.egress_filter = egress_filter if egress_filter is not None else ''
2349        '''
2350         A filter applied to the routing logic to pin datasource to nodes.
2351        '''
2352        self.healthy = healthy if healthy is not None else False
2353        '''
2354         True if the datasource is reachable and the credentials are valid.
2355        '''
2356        self.id = id if id is not None else ''
2357        '''
2358         Unique identifier of the Resource.
2359        '''
2360        self.name = name if name is not None else ''
2361        '''
2362         Unique human-readable name of the Resource.
2363        '''
2364        self.output = output if output is not None else ''
2365        self.port_override = port_override if port_override is not None else 0
2366        self.region = region if region is not None else ''
2367        self.role_arn = role_arn if role_arn is not None else ''
2368        self.role_external_id = role_external_id if role_external_id is not None else ''
2369        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2370        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2371        '''
2372         ID of the secret store containing credentials for this resource, if any.
2373        '''
2374        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2375        '''
2376         Tags is a map of key, value pairs.
2377        '''
2378
2379    def __repr__(self):
2380        return '<sdm.Athena ' + \
2381            'access_key: ' + repr(self.access_key) + ' ' +\
2382            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2383            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2384            'healthy: ' + repr(self.healthy) + ' ' +\
2385            'id: ' + repr(self.id) + ' ' +\
2386            'name: ' + repr(self.name) + ' ' +\
2387            'output: ' + repr(self.output) + ' ' +\
2388            'port_override: ' + repr(self.port_override) + ' ' +\
2389            'region: ' + repr(self.region) + ' ' +\
2390            'role_arn: ' + repr(self.role_arn) + ' ' +\
2391            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2392            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2393            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2394            'tags: ' + repr(self.tags) + ' ' +\
2395            '>'
2396
2397    def to_dict(self):
2398        return {
2399            'access_key': self.access_key,
2400            'bind_interface': self.bind_interface,
2401            'egress_filter': self.egress_filter,
2402            'healthy': self.healthy,
2403            'id': self.id,
2404            'name': self.name,
2405            'output': self.output,
2406            'port_override': self.port_override,
2407            'region': self.region,
2408            'role_arn': self.role_arn,
2409            'role_external_id': self.role_external_id,
2410            'secret_access_key': self.secret_access_key,
2411            'secret_store_id': self.secret_store_id,
2412            'tags': self.tags,
2413        }
2414
2415    @classmethod
2416    def from_dict(cls, d):
2417        return cls(
2418            access_key=d.get('access_key'),
2419            bind_interface=d.get('bind_interface'),
2420            egress_filter=d.get('egress_filter'),
2421            healthy=d.get('healthy'),
2422            id=d.get('id'),
2423            name=d.get('name'),
2424            output=d.get('output'),
2425            port_override=d.get('port_override'),
2426            region=d.get('region'),
2427            role_arn=d.get('role_arn'),
2428            role_external_id=d.get('role_external_id'),
2429            secret_access_key=d.get('secret_access_key'),
2430            secret_store_id=d.get('secret_store_id'),
2431            tags=d.get('tags'),
2432        )
Athena( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2326    def __init__(
2327        self,
2328        access_key=None,
2329        bind_interface=None,
2330        egress_filter=None,
2331        healthy=None,
2332        id=None,
2333        name=None,
2334        output=None,
2335        port_override=None,
2336        region=None,
2337        role_arn=None,
2338        role_external_id=None,
2339        secret_access_key=None,
2340        secret_store_id=None,
2341        tags=None,
2342    ):
2343        self.access_key = access_key if access_key is not None else ''
2344        self.bind_interface = bind_interface if bind_interface is not None else ''
2345        '''
2346         Bind interface
2347        '''
2348        self.egress_filter = egress_filter if egress_filter is not None else ''
2349        '''
2350         A filter applied to the routing logic to pin datasource to nodes.
2351        '''
2352        self.healthy = healthy if healthy is not None else False
2353        '''
2354         True if the datasource is reachable and the credentials are valid.
2355        '''
2356        self.id = id if id is not None else ''
2357        '''
2358         Unique identifier of the Resource.
2359        '''
2360        self.name = name if name is not None else ''
2361        '''
2362         Unique human-readable name of the Resource.
2363        '''
2364        self.output = output if output is not None else ''
2365        self.port_override = port_override if port_override is not None else 0
2366        self.region = region if region is not None else ''
2367        self.role_arn = role_arn if role_arn is not None else ''
2368        self.role_external_id = role_external_id if role_external_id is not None else ''
2369        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2370        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2371        '''
2372         ID of the secret store containing credentials for this resource, if any.
2373        '''
2374        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2375        '''
2376         Tags is a map of key, value pairs.
2377        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

output
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2397    def to_dict(self):
2398        return {
2399            'access_key': self.access_key,
2400            'bind_interface': self.bind_interface,
2401            'egress_filter': self.egress_filter,
2402            'healthy': self.healthy,
2403            'id': self.id,
2404            'name': self.name,
2405            'output': self.output,
2406            'port_override': self.port_override,
2407            'region': self.region,
2408            'role_arn': self.role_arn,
2409            'role_external_id': self.role_external_id,
2410            'secret_access_key': self.secret_access_key,
2411            'secret_store_id': self.secret_store_id,
2412            'tags': self.tags,
2413        }
@classmethod
def from_dict(cls, d)
2415    @classmethod
2416    def from_dict(cls, d):
2417        return cls(
2418            access_key=d.get('access_key'),
2419            bind_interface=d.get('bind_interface'),
2420            egress_filter=d.get('egress_filter'),
2421            healthy=d.get('healthy'),
2422            id=d.get('id'),
2423            name=d.get('name'),
2424            output=d.get('output'),
2425            port_override=d.get('port_override'),
2426            region=d.get('region'),
2427            role_arn=d.get('role_arn'),
2428            role_external_id=d.get('role_external_id'),
2429            secret_access_key=d.get('secret_access_key'),
2430            secret_store_id=d.get('secret_store_id'),
2431            tags=d.get('tags'),
2432        )
class AuroraMysql:
2435class AuroraMysql:
2436    __slots__ = [
2437        'bind_interface',
2438        'database',
2439        'egress_filter',
2440        'healthy',
2441        'hostname',
2442        'id',
2443        'name',
2444        'password',
2445        'port',
2446        'port_override',
2447        'secret_store_id',
2448        'tags',
2449        'username',
2450    ]
2451
2452    def __init__(
2453        self,
2454        bind_interface=None,
2455        database=None,
2456        egress_filter=None,
2457        healthy=None,
2458        hostname=None,
2459        id=None,
2460        name=None,
2461        password=None,
2462        port=None,
2463        port_override=None,
2464        secret_store_id=None,
2465        tags=None,
2466        username=None,
2467    ):
2468        self.bind_interface = bind_interface if bind_interface is not None else ''
2469        '''
2470         Bind interface
2471        '''
2472        self.database = database if database is not None else ''
2473        self.egress_filter = egress_filter if egress_filter is not None else ''
2474        '''
2475         A filter applied to the routing logic to pin datasource to nodes.
2476        '''
2477        self.healthy = healthy if healthy is not None else False
2478        '''
2479         True if the datasource is reachable and the credentials are valid.
2480        '''
2481        self.hostname = hostname if hostname is not None else ''
2482        self.id = id if id is not None else ''
2483        '''
2484         Unique identifier of the Resource.
2485        '''
2486        self.name = name if name is not None else ''
2487        '''
2488         Unique human-readable name of the Resource.
2489        '''
2490        self.password = password if password is not None else ''
2491        self.port = port if port is not None else 0
2492        self.port_override = port_override if port_override is not None else 0
2493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2494        '''
2495         ID of the secret store containing credentials for this resource, if any.
2496        '''
2497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2498        '''
2499         Tags is a map of key, value pairs.
2500        '''
2501        self.username = username if username is not None else ''
2502
2503    def __repr__(self):
2504        return '<sdm.AuroraMysql ' + \
2505            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2506            'database: ' + repr(self.database) + ' ' +\
2507            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2508            'healthy: ' + repr(self.healthy) + ' ' +\
2509            'hostname: ' + repr(self.hostname) + ' ' +\
2510            'id: ' + repr(self.id) + ' ' +\
2511            'name: ' + repr(self.name) + ' ' +\
2512            'password: ' + repr(self.password) + ' ' +\
2513            'port: ' + repr(self.port) + ' ' +\
2514            'port_override: ' + repr(self.port_override) + ' ' +\
2515            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2516            'tags: ' + repr(self.tags) + ' ' +\
2517            'username: ' + repr(self.username) + ' ' +\
2518            '>'
2519
2520    def to_dict(self):
2521        return {
2522            'bind_interface': self.bind_interface,
2523            'database': self.database,
2524            'egress_filter': self.egress_filter,
2525            'healthy': self.healthy,
2526            'hostname': self.hostname,
2527            'id': self.id,
2528            'name': self.name,
2529            'password': self.password,
2530            'port': self.port,
2531            'port_override': self.port_override,
2532            'secret_store_id': self.secret_store_id,
2533            'tags': self.tags,
2534            'username': self.username,
2535        }
2536
2537    @classmethod
2538    def from_dict(cls, d):
2539        return cls(
2540            bind_interface=d.get('bind_interface'),
2541            database=d.get('database'),
2542            egress_filter=d.get('egress_filter'),
2543            healthy=d.get('healthy'),
2544            hostname=d.get('hostname'),
2545            id=d.get('id'),
2546            name=d.get('name'),
2547            password=d.get('password'),
2548            port=d.get('port'),
2549            port_override=d.get('port_override'),
2550            secret_store_id=d.get('secret_store_id'),
2551            tags=d.get('tags'),
2552            username=d.get('username'),
2553        )
AuroraMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2452    def __init__(
2453        self,
2454        bind_interface=None,
2455        database=None,
2456        egress_filter=None,
2457        healthy=None,
2458        hostname=None,
2459        id=None,
2460        name=None,
2461        password=None,
2462        port=None,
2463        port_override=None,
2464        secret_store_id=None,
2465        tags=None,
2466        username=None,
2467    ):
2468        self.bind_interface = bind_interface if bind_interface is not None else ''
2469        '''
2470         Bind interface
2471        '''
2472        self.database = database if database is not None else ''
2473        self.egress_filter = egress_filter if egress_filter is not None else ''
2474        '''
2475         A filter applied to the routing logic to pin datasource to nodes.
2476        '''
2477        self.healthy = healthy if healthy is not None else False
2478        '''
2479         True if the datasource is reachable and the credentials are valid.
2480        '''
2481        self.hostname = hostname if hostname is not None else ''
2482        self.id = id if id is not None else ''
2483        '''
2484         Unique identifier of the Resource.
2485        '''
2486        self.name = name if name is not None else ''
2487        '''
2488         Unique human-readable name of the Resource.
2489        '''
2490        self.password = password if password is not None else ''
2491        self.port = port if port is not None else 0
2492        self.port_override = port_override if port_override is not None else 0
2493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2494        '''
2495         ID of the secret store containing credentials for this resource, if any.
2496        '''
2497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2498        '''
2499         Tags is a map of key, value pairs.
2500        '''
2501        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2520    def to_dict(self):
2521        return {
2522            'bind_interface': self.bind_interface,
2523            'database': self.database,
2524            'egress_filter': self.egress_filter,
2525            'healthy': self.healthy,
2526            'hostname': self.hostname,
2527            'id': self.id,
2528            'name': self.name,
2529            'password': self.password,
2530            'port': self.port,
2531            'port_override': self.port_override,
2532            'secret_store_id': self.secret_store_id,
2533            'tags': self.tags,
2534            'username': self.username,
2535        }
@classmethod
def from_dict(cls, d)
2537    @classmethod
2538    def from_dict(cls, d):
2539        return cls(
2540            bind_interface=d.get('bind_interface'),
2541            database=d.get('database'),
2542            egress_filter=d.get('egress_filter'),
2543            healthy=d.get('healthy'),
2544            hostname=d.get('hostname'),
2545            id=d.get('id'),
2546            name=d.get('name'),
2547            password=d.get('password'),
2548            port=d.get('port'),
2549            port_override=d.get('port_override'),
2550            secret_store_id=d.get('secret_store_id'),
2551            tags=d.get('tags'),
2552            username=d.get('username'),
2553        )
class AuroraPostgres:
2556class AuroraPostgres:
2557    __slots__ = [
2558        'bind_interface',
2559        'database',
2560        'egress_filter',
2561        'healthy',
2562        'hostname',
2563        'id',
2564        'name',
2565        'override_database',
2566        'password',
2567        'port',
2568        'port_override',
2569        'secret_store_id',
2570        'tags',
2571        'username',
2572    ]
2573
2574    def __init__(
2575        self,
2576        bind_interface=None,
2577        database=None,
2578        egress_filter=None,
2579        healthy=None,
2580        hostname=None,
2581        id=None,
2582        name=None,
2583        override_database=None,
2584        password=None,
2585        port=None,
2586        port_override=None,
2587        secret_store_id=None,
2588        tags=None,
2589        username=None,
2590    ):
2591        self.bind_interface = bind_interface if bind_interface is not None else ''
2592        '''
2593         Bind interface
2594        '''
2595        self.database = database if database is not None else ''
2596        self.egress_filter = egress_filter if egress_filter is not None else ''
2597        '''
2598         A filter applied to the routing logic to pin datasource to nodes.
2599        '''
2600        self.healthy = healthy if healthy is not None else False
2601        '''
2602         True if the datasource is reachable and the credentials are valid.
2603        '''
2604        self.hostname = hostname if hostname is not None else ''
2605        self.id = id if id is not None else ''
2606        '''
2607         Unique identifier of the Resource.
2608        '''
2609        self.name = name if name is not None else ''
2610        '''
2611         Unique human-readable name of the Resource.
2612        '''
2613        self.override_database = override_database if override_database is not None else False
2614        self.password = password if password is not None else ''
2615        self.port = port if port is not None else 0
2616        self.port_override = port_override if port_override is not None else 0
2617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2618        '''
2619         ID of the secret store containing credentials for this resource, if any.
2620        '''
2621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2622        '''
2623         Tags is a map of key, value pairs.
2624        '''
2625        self.username = username if username is not None else ''
2626
2627    def __repr__(self):
2628        return '<sdm.AuroraPostgres ' + \
2629            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2630            'database: ' + repr(self.database) + ' ' +\
2631            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2632            'healthy: ' + repr(self.healthy) + ' ' +\
2633            'hostname: ' + repr(self.hostname) + ' ' +\
2634            'id: ' + repr(self.id) + ' ' +\
2635            'name: ' + repr(self.name) + ' ' +\
2636            'override_database: ' + repr(self.override_database) + ' ' +\
2637            'password: ' + repr(self.password) + ' ' +\
2638            'port: ' + repr(self.port) + ' ' +\
2639            'port_override: ' + repr(self.port_override) + ' ' +\
2640            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2641            'tags: ' + repr(self.tags) + ' ' +\
2642            'username: ' + repr(self.username) + ' ' +\
2643            '>'
2644
2645    def to_dict(self):
2646        return {
2647            'bind_interface': self.bind_interface,
2648            'database': self.database,
2649            'egress_filter': self.egress_filter,
2650            'healthy': self.healthy,
2651            'hostname': self.hostname,
2652            'id': self.id,
2653            'name': self.name,
2654            'override_database': self.override_database,
2655            'password': self.password,
2656            'port': self.port,
2657            'port_override': self.port_override,
2658            'secret_store_id': self.secret_store_id,
2659            'tags': self.tags,
2660            'username': self.username,
2661        }
2662
2663    @classmethod
2664    def from_dict(cls, d):
2665        return cls(
2666            bind_interface=d.get('bind_interface'),
2667            database=d.get('database'),
2668            egress_filter=d.get('egress_filter'),
2669            healthy=d.get('healthy'),
2670            hostname=d.get('hostname'),
2671            id=d.get('id'),
2672            name=d.get('name'),
2673            override_database=d.get('override_database'),
2674            password=d.get('password'),
2675            port=d.get('port'),
2676            port_override=d.get('port_override'),
2677            secret_store_id=d.get('secret_store_id'),
2678            tags=d.get('tags'),
2679            username=d.get('username'),
2680        )
AuroraPostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2574    def __init__(
2575        self,
2576        bind_interface=None,
2577        database=None,
2578        egress_filter=None,
2579        healthy=None,
2580        hostname=None,
2581        id=None,
2582        name=None,
2583        override_database=None,
2584        password=None,
2585        port=None,
2586        port_override=None,
2587        secret_store_id=None,
2588        tags=None,
2589        username=None,
2590    ):
2591        self.bind_interface = bind_interface if bind_interface is not None else ''
2592        '''
2593         Bind interface
2594        '''
2595        self.database = database if database is not None else ''
2596        self.egress_filter = egress_filter if egress_filter is not None else ''
2597        '''
2598         A filter applied to the routing logic to pin datasource to nodes.
2599        '''
2600        self.healthy = healthy if healthy is not None else False
2601        '''
2602         True if the datasource is reachable and the credentials are valid.
2603        '''
2604        self.hostname = hostname if hostname is not None else ''
2605        self.id = id if id is not None else ''
2606        '''
2607         Unique identifier of the Resource.
2608        '''
2609        self.name = name if name is not None else ''
2610        '''
2611         Unique human-readable name of the Resource.
2612        '''
2613        self.override_database = override_database if override_database is not None else False
2614        self.password = password if password is not None else ''
2615        self.port = port if port is not None else 0
2616        self.port_override = port_override if port_override is not None else 0
2617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2618        '''
2619         ID of the secret store containing credentials for this resource, if any.
2620        '''
2621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2622        '''
2623         Tags is a map of key, value pairs.
2624        '''
2625        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2645    def to_dict(self):
2646        return {
2647            'bind_interface': self.bind_interface,
2648            'database': self.database,
2649            'egress_filter': self.egress_filter,
2650            'healthy': self.healthy,
2651            'hostname': self.hostname,
2652            'id': self.id,
2653            'name': self.name,
2654            'override_database': self.override_database,
2655            'password': self.password,
2656            'port': self.port,
2657            'port_override': self.port_override,
2658            'secret_store_id': self.secret_store_id,
2659            'tags': self.tags,
2660            'username': self.username,
2661        }
@classmethod
def from_dict(cls, d)
2663    @classmethod
2664    def from_dict(cls, d):
2665        return cls(
2666            bind_interface=d.get('bind_interface'),
2667            database=d.get('database'),
2668            egress_filter=d.get('egress_filter'),
2669            healthy=d.get('healthy'),
2670            hostname=d.get('hostname'),
2671            id=d.get('id'),
2672            name=d.get('name'),
2673            override_database=d.get('override_database'),
2674            password=d.get('password'),
2675            port=d.get('port'),
2676            port_override=d.get('port_override'),
2677            secret_store_id=d.get('secret_store_id'),
2678            tags=d.get('tags'),
2679            username=d.get('username'),
2680        )
class Azure:
2683class Azure:
2684    __slots__ = [
2685        'app_id',
2686        'bind_interface',
2687        'egress_filter',
2688        'healthy',
2689        'id',
2690        'name',
2691        'password',
2692        'secret_store_id',
2693        'tags',
2694        'tenant_id',
2695    ]
2696
2697    def __init__(
2698        self,
2699        app_id=None,
2700        bind_interface=None,
2701        egress_filter=None,
2702        healthy=None,
2703        id=None,
2704        name=None,
2705        password=None,
2706        secret_store_id=None,
2707        tags=None,
2708        tenant_id=None,
2709    ):
2710        self.app_id = app_id if app_id is not None else ''
2711        self.bind_interface = bind_interface if bind_interface is not None else ''
2712        '''
2713         Bind interface
2714        '''
2715        self.egress_filter = egress_filter if egress_filter is not None else ''
2716        '''
2717         A filter applied to the routing logic to pin datasource to nodes.
2718        '''
2719        self.healthy = healthy if healthy is not None else False
2720        '''
2721         True if the datasource is reachable and the credentials are valid.
2722        '''
2723        self.id = id if id is not None else ''
2724        '''
2725         Unique identifier of the Resource.
2726        '''
2727        self.name = name if name is not None else ''
2728        '''
2729         Unique human-readable name of the Resource.
2730        '''
2731        self.password = password if password is not None else ''
2732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2733        '''
2734         ID of the secret store containing credentials for this resource, if any.
2735        '''
2736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2737        '''
2738         Tags is a map of key, value pairs.
2739        '''
2740        self.tenant_id = tenant_id if tenant_id is not None else ''
2741
2742    def __repr__(self):
2743        return '<sdm.Azure ' + \
2744            'app_id: ' + repr(self.app_id) + ' ' +\
2745            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2746            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2747            'healthy: ' + repr(self.healthy) + ' ' +\
2748            'id: ' + repr(self.id) + ' ' +\
2749            'name: ' + repr(self.name) + ' ' +\
2750            'password: ' + repr(self.password) + ' ' +\
2751            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2752            'tags: ' + repr(self.tags) + ' ' +\
2753            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2754            '>'
2755
2756    def to_dict(self):
2757        return {
2758            'app_id': self.app_id,
2759            'bind_interface': self.bind_interface,
2760            'egress_filter': self.egress_filter,
2761            'healthy': self.healthy,
2762            'id': self.id,
2763            'name': self.name,
2764            'password': self.password,
2765            'secret_store_id': self.secret_store_id,
2766            'tags': self.tags,
2767            'tenant_id': self.tenant_id,
2768        }
2769
2770    @classmethod
2771    def from_dict(cls, d):
2772        return cls(
2773            app_id=d.get('app_id'),
2774            bind_interface=d.get('bind_interface'),
2775            egress_filter=d.get('egress_filter'),
2776            healthy=d.get('healthy'),
2777            id=d.get('id'),
2778            name=d.get('name'),
2779            password=d.get('password'),
2780            secret_store_id=d.get('secret_store_id'),
2781            tags=d.get('tags'),
2782            tenant_id=d.get('tenant_id'),
2783        )
Azure( app_id=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None)
2697    def __init__(
2698        self,
2699        app_id=None,
2700        bind_interface=None,
2701        egress_filter=None,
2702        healthy=None,
2703        id=None,
2704        name=None,
2705        password=None,
2706        secret_store_id=None,
2707        tags=None,
2708        tenant_id=None,
2709    ):
2710        self.app_id = app_id if app_id is not None else ''
2711        self.bind_interface = bind_interface if bind_interface is not None else ''
2712        '''
2713         Bind interface
2714        '''
2715        self.egress_filter = egress_filter if egress_filter is not None else ''
2716        '''
2717         A filter applied to the routing logic to pin datasource to nodes.
2718        '''
2719        self.healthy = healthy if healthy is not None else False
2720        '''
2721         True if the datasource is reachable and the credentials are valid.
2722        '''
2723        self.id = id if id is not None else ''
2724        '''
2725         Unique identifier of the Resource.
2726        '''
2727        self.name = name if name is not None else ''
2728        '''
2729         Unique human-readable name of the Resource.
2730        '''
2731        self.password = password if password is not None else ''
2732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2733        '''
2734         ID of the secret store containing credentials for this resource, if any.
2735        '''
2736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2737        '''
2738         Tags is a map of key, value pairs.
2739        '''
2740        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2756    def to_dict(self):
2757        return {
2758            'app_id': self.app_id,
2759            'bind_interface': self.bind_interface,
2760            'egress_filter': self.egress_filter,
2761            'healthy': self.healthy,
2762            'id': self.id,
2763            'name': self.name,
2764            'password': self.password,
2765            'secret_store_id': self.secret_store_id,
2766            'tags': self.tags,
2767            'tenant_id': self.tenant_id,
2768        }
@classmethod
def from_dict(cls, d)
2770    @classmethod
2771    def from_dict(cls, d):
2772        return cls(
2773            app_id=d.get('app_id'),
2774            bind_interface=d.get('bind_interface'),
2775            egress_filter=d.get('egress_filter'),
2776            healthy=d.get('healthy'),
2777            id=d.get('id'),
2778            name=d.get('name'),
2779            password=d.get('password'),
2780            secret_store_id=d.get('secret_store_id'),
2781            tags=d.get('tags'),
2782            tenant_id=d.get('tenant_id'),
2783        )
class AzureCertificate:
2786class AzureCertificate:
2787    __slots__ = [
2788        'app_id',
2789        'bind_interface',
2790        'client_certificate',
2791        'egress_filter',
2792        'healthy',
2793        'id',
2794        'name',
2795        'secret_store_id',
2796        'tags',
2797        'tenant_id',
2798    ]
2799
2800    def __init__(
2801        self,
2802        app_id=None,
2803        bind_interface=None,
2804        client_certificate=None,
2805        egress_filter=None,
2806        healthy=None,
2807        id=None,
2808        name=None,
2809        secret_store_id=None,
2810        tags=None,
2811        tenant_id=None,
2812    ):
2813        self.app_id = app_id if app_id is not None else ''
2814        self.bind_interface = bind_interface if bind_interface is not None else ''
2815        '''
2816         Bind interface
2817        '''
2818        self.client_certificate = client_certificate if client_certificate is not None else ''
2819        self.egress_filter = egress_filter if egress_filter is not None else ''
2820        '''
2821         A filter applied to the routing logic to pin datasource to nodes.
2822        '''
2823        self.healthy = healthy if healthy is not None else False
2824        '''
2825         True if the datasource is reachable and the credentials are valid.
2826        '''
2827        self.id = id if id is not None else ''
2828        '''
2829         Unique identifier of the Resource.
2830        '''
2831        self.name = name if name is not None else ''
2832        '''
2833         Unique human-readable name of the Resource.
2834        '''
2835        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2836        '''
2837         ID of the secret store containing credentials for this resource, if any.
2838        '''
2839        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2840        '''
2841         Tags is a map of key, value pairs.
2842        '''
2843        self.tenant_id = tenant_id if tenant_id is not None else ''
2844
2845    def __repr__(self):
2846        return '<sdm.AzureCertificate ' + \
2847            'app_id: ' + repr(self.app_id) + ' ' +\
2848            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2849            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
2850            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2851            'healthy: ' + repr(self.healthy) + ' ' +\
2852            'id: ' + repr(self.id) + ' ' +\
2853            'name: ' + repr(self.name) + ' ' +\
2854            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2855            'tags: ' + repr(self.tags) + ' ' +\
2856            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2857            '>'
2858
2859    def to_dict(self):
2860        return {
2861            'app_id': self.app_id,
2862            'bind_interface': self.bind_interface,
2863            'client_certificate': self.client_certificate,
2864            'egress_filter': self.egress_filter,
2865            'healthy': self.healthy,
2866            'id': self.id,
2867            'name': self.name,
2868            'secret_store_id': self.secret_store_id,
2869            'tags': self.tags,
2870            'tenant_id': self.tenant_id,
2871        }
2872
2873    @classmethod
2874    def from_dict(cls, d):
2875        return cls(
2876            app_id=d.get('app_id'),
2877            bind_interface=d.get('bind_interface'),
2878            client_certificate=d.get('client_certificate'),
2879            egress_filter=d.get('egress_filter'),
2880            healthy=d.get('healthy'),
2881            id=d.get('id'),
2882            name=d.get('name'),
2883            secret_store_id=d.get('secret_store_id'),
2884            tags=d.get('tags'),
2885            tenant_id=d.get('tenant_id'),
2886        )
AzureCertificate( app_id=None, bind_interface=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None)
2800    def __init__(
2801        self,
2802        app_id=None,
2803        bind_interface=None,
2804        client_certificate=None,
2805        egress_filter=None,
2806        healthy=None,
2807        id=None,
2808        name=None,
2809        secret_store_id=None,
2810        tags=None,
2811        tenant_id=None,
2812    ):
2813        self.app_id = app_id if app_id is not None else ''
2814        self.bind_interface = bind_interface if bind_interface is not None else ''
2815        '''
2816         Bind interface
2817        '''
2818        self.client_certificate = client_certificate if client_certificate is not None else ''
2819        self.egress_filter = egress_filter if egress_filter is not None else ''
2820        '''
2821         A filter applied to the routing logic to pin datasource to nodes.
2822        '''
2823        self.healthy = healthy if healthy is not None else False
2824        '''
2825         True if the datasource is reachable and the credentials are valid.
2826        '''
2827        self.id = id if id is not None else ''
2828        '''
2829         Unique identifier of the Resource.
2830        '''
2831        self.name = name if name is not None else ''
2832        '''
2833         Unique human-readable name of the Resource.
2834        '''
2835        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2836        '''
2837         ID of the secret store containing credentials for this resource, if any.
2838        '''
2839        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2840        '''
2841         Tags is a map of key, value pairs.
2842        '''
2843        self.tenant_id = tenant_id if tenant_id is not None else ''
app_id
bind_interface

Bind interface

client_certificate
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2859    def to_dict(self):
2860        return {
2861            'app_id': self.app_id,
2862            'bind_interface': self.bind_interface,
2863            'client_certificate': self.client_certificate,
2864            'egress_filter': self.egress_filter,
2865            'healthy': self.healthy,
2866            'id': self.id,
2867            'name': self.name,
2868            'secret_store_id': self.secret_store_id,
2869            'tags': self.tags,
2870            'tenant_id': self.tenant_id,
2871        }
@classmethod
def from_dict(cls, d)
2873    @classmethod
2874    def from_dict(cls, d):
2875        return cls(
2876            app_id=d.get('app_id'),
2877            bind_interface=d.get('bind_interface'),
2878            client_certificate=d.get('client_certificate'),
2879            egress_filter=d.get('egress_filter'),
2880            healthy=d.get('healthy'),
2881            id=d.get('id'),
2882            name=d.get('name'),
2883            secret_store_id=d.get('secret_store_id'),
2884            tags=d.get('tags'),
2885            tenant_id=d.get('tenant_id'),
2886        )
class AzureMysql:
2889class AzureMysql:
2890    '''
2891    AzureMysql is currently unstable, and its API may change, or it may be removed,
2892    without a major version bump.
2893    '''
2894    __slots__ = [
2895        'bind_interface',
2896        'database',
2897        'egress_filter',
2898        'healthy',
2899        'hostname',
2900        'id',
2901        'name',
2902        'password',
2903        'port',
2904        'port_override',
2905        'secret_store_id',
2906        'tags',
2907        'username',
2908    ]
2909
2910    def __init__(
2911        self,
2912        bind_interface=None,
2913        database=None,
2914        egress_filter=None,
2915        healthy=None,
2916        hostname=None,
2917        id=None,
2918        name=None,
2919        password=None,
2920        port=None,
2921        port_override=None,
2922        secret_store_id=None,
2923        tags=None,
2924        username=None,
2925    ):
2926        self.bind_interface = bind_interface if bind_interface is not None else ''
2927        '''
2928         Bind interface
2929        '''
2930        self.database = database if database is not None else ''
2931        self.egress_filter = egress_filter if egress_filter is not None else ''
2932        '''
2933         A filter applied to the routing logic to pin datasource to nodes.
2934        '''
2935        self.healthy = healthy if healthy is not None else False
2936        '''
2937         True if the datasource is reachable and the credentials are valid.
2938        '''
2939        self.hostname = hostname if hostname is not None else ''
2940        self.id = id if id is not None else ''
2941        '''
2942         Unique identifier of the Resource.
2943        '''
2944        self.name = name if name is not None else ''
2945        '''
2946         Unique human-readable name of the Resource.
2947        '''
2948        self.password = password if password is not None else ''
2949        self.port = port if port is not None else 0
2950        self.port_override = port_override if port_override is not None else 0
2951        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2952        '''
2953         ID of the secret store containing credentials for this resource, if any.
2954        '''
2955        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2956        '''
2957         Tags is a map of key, value pairs.
2958        '''
2959        self.username = username if username is not None else ''
2960
2961    def __repr__(self):
2962        return '<sdm.AzureMysql ' + \
2963            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2964            'database: ' + repr(self.database) + ' ' +\
2965            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2966            'healthy: ' + repr(self.healthy) + ' ' +\
2967            'hostname: ' + repr(self.hostname) + ' ' +\
2968            'id: ' + repr(self.id) + ' ' +\
2969            'name: ' + repr(self.name) + ' ' +\
2970            'password: ' + repr(self.password) + ' ' +\
2971            'port: ' + repr(self.port) + ' ' +\
2972            'port_override: ' + repr(self.port_override) + ' ' +\
2973            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2974            'tags: ' + repr(self.tags) + ' ' +\
2975            'username: ' + repr(self.username) + ' ' +\
2976            '>'
2977
2978    def to_dict(self):
2979        return {
2980            'bind_interface': self.bind_interface,
2981            'database': self.database,
2982            'egress_filter': self.egress_filter,
2983            'healthy': self.healthy,
2984            'hostname': self.hostname,
2985            'id': self.id,
2986            'name': self.name,
2987            'password': self.password,
2988            'port': self.port,
2989            'port_override': self.port_override,
2990            'secret_store_id': self.secret_store_id,
2991            'tags': self.tags,
2992            'username': self.username,
2993        }
2994
2995    @classmethod
2996    def from_dict(cls, d):
2997        return cls(
2998            bind_interface=d.get('bind_interface'),
2999            database=d.get('database'),
3000            egress_filter=d.get('egress_filter'),
3001            healthy=d.get('healthy'),
3002            hostname=d.get('hostname'),
3003            id=d.get('id'),
3004            name=d.get('name'),
3005            password=d.get('password'),
3006            port=d.get('port'),
3007            port_override=d.get('port_override'),
3008            secret_store_id=d.get('secret_store_id'),
3009            tags=d.get('tags'),
3010            username=d.get('username'),
3011        )

AzureMysql is currently unstable, and its API may change, or it may be removed, without a major version bump.

AzureMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2910    def __init__(
2911        self,
2912        bind_interface=None,
2913        database=None,
2914        egress_filter=None,
2915        healthy=None,
2916        hostname=None,
2917        id=None,
2918        name=None,
2919        password=None,
2920        port=None,
2921        port_override=None,
2922        secret_store_id=None,
2923        tags=None,
2924        username=None,
2925    ):
2926        self.bind_interface = bind_interface if bind_interface is not None else ''
2927        '''
2928         Bind interface
2929        '''
2930        self.database = database if database is not None else ''
2931        self.egress_filter = egress_filter if egress_filter is not None else ''
2932        '''
2933         A filter applied to the routing logic to pin datasource to nodes.
2934        '''
2935        self.healthy = healthy if healthy is not None else False
2936        '''
2937         True if the datasource is reachable and the credentials are valid.
2938        '''
2939        self.hostname = hostname if hostname is not None else ''
2940        self.id = id if id is not None else ''
2941        '''
2942         Unique identifier of the Resource.
2943        '''
2944        self.name = name if name is not None else ''
2945        '''
2946         Unique human-readable name of the Resource.
2947        '''
2948        self.password = password if password is not None else ''
2949        self.port = port if port is not None else 0
2950        self.port_override = port_override if port_override is not None else 0
2951        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2952        '''
2953         ID of the secret store containing credentials for this resource, if any.
2954        '''
2955        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2956        '''
2957         Tags is a map of key, value pairs.
2958        '''
2959        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2978    def to_dict(self):
2979        return {
2980            'bind_interface': self.bind_interface,
2981            'database': self.database,
2982            'egress_filter': self.egress_filter,
2983            'healthy': self.healthy,
2984            'hostname': self.hostname,
2985            'id': self.id,
2986            'name': self.name,
2987            'password': self.password,
2988            'port': self.port,
2989            'port_override': self.port_override,
2990            'secret_store_id': self.secret_store_id,
2991            'tags': self.tags,
2992            'username': self.username,
2993        }
@classmethod
def from_dict(cls, d)
2995    @classmethod
2996    def from_dict(cls, d):
2997        return cls(
2998            bind_interface=d.get('bind_interface'),
2999            database=d.get('database'),
3000            egress_filter=d.get('egress_filter'),
3001            healthy=d.get('healthy'),
3002            hostname=d.get('hostname'),
3003            id=d.get('id'),
3004            name=d.get('name'),
3005            password=d.get('password'),
3006            port=d.get('port'),
3007            port_override=d.get('port_override'),
3008            secret_store_id=d.get('secret_store_id'),
3009            tags=d.get('tags'),
3010            username=d.get('username'),
3011        )
class AzurePostgres:
3014class AzurePostgres:
3015    __slots__ = [
3016        'bind_interface',
3017        'database',
3018        'egress_filter',
3019        'healthy',
3020        'hostname',
3021        'id',
3022        'name',
3023        'override_database',
3024        'password',
3025        'port',
3026        'port_override',
3027        'secret_store_id',
3028        'tags',
3029        'username',
3030    ]
3031
3032    def __init__(
3033        self,
3034        bind_interface=None,
3035        database=None,
3036        egress_filter=None,
3037        healthy=None,
3038        hostname=None,
3039        id=None,
3040        name=None,
3041        override_database=None,
3042        password=None,
3043        port=None,
3044        port_override=None,
3045        secret_store_id=None,
3046        tags=None,
3047        username=None,
3048    ):
3049        self.bind_interface = bind_interface if bind_interface is not None else ''
3050        '''
3051         Bind interface
3052        '''
3053        self.database = database if database is not None else ''
3054        self.egress_filter = egress_filter if egress_filter is not None else ''
3055        '''
3056         A filter applied to the routing logic to pin datasource to nodes.
3057        '''
3058        self.healthy = healthy if healthy is not None else False
3059        '''
3060         True if the datasource is reachable and the credentials are valid.
3061        '''
3062        self.hostname = hostname if hostname is not None else ''
3063        self.id = id if id is not None else ''
3064        '''
3065         Unique identifier of the Resource.
3066        '''
3067        self.name = name if name is not None else ''
3068        '''
3069         Unique human-readable name of the Resource.
3070        '''
3071        self.override_database = override_database if override_database is not None else False
3072        self.password = password if password is not None else ''
3073        self.port = port if port is not None else 0
3074        self.port_override = port_override if port_override is not None else 0
3075        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3076        '''
3077         ID of the secret store containing credentials for this resource, if any.
3078        '''
3079        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3080        '''
3081         Tags is a map of key, value pairs.
3082        '''
3083        self.username = username if username is not None else ''
3084
3085    def __repr__(self):
3086        return '<sdm.AzurePostgres ' + \
3087            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3088            'database: ' + repr(self.database) + ' ' +\
3089            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3090            'healthy: ' + repr(self.healthy) + ' ' +\
3091            'hostname: ' + repr(self.hostname) + ' ' +\
3092            'id: ' + repr(self.id) + ' ' +\
3093            'name: ' + repr(self.name) + ' ' +\
3094            'override_database: ' + repr(self.override_database) + ' ' +\
3095            'password: ' + repr(self.password) + ' ' +\
3096            'port: ' + repr(self.port) + ' ' +\
3097            'port_override: ' + repr(self.port_override) + ' ' +\
3098            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3099            'tags: ' + repr(self.tags) + ' ' +\
3100            'username: ' + repr(self.username) + ' ' +\
3101            '>'
3102
3103    def to_dict(self):
3104        return {
3105            'bind_interface': self.bind_interface,
3106            'database': self.database,
3107            'egress_filter': self.egress_filter,
3108            'healthy': self.healthy,
3109            'hostname': self.hostname,
3110            'id': self.id,
3111            'name': self.name,
3112            'override_database': self.override_database,
3113            'password': self.password,
3114            'port': self.port,
3115            'port_override': self.port_override,
3116            'secret_store_id': self.secret_store_id,
3117            'tags': self.tags,
3118            'username': self.username,
3119        }
3120
3121    @classmethod
3122    def from_dict(cls, d):
3123        return cls(
3124            bind_interface=d.get('bind_interface'),
3125            database=d.get('database'),
3126            egress_filter=d.get('egress_filter'),
3127            healthy=d.get('healthy'),
3128            hostname=d.get('hostname'),
3129            id=d.get('id'),
3130            name=d.get('name'),
3131            override_database=d.get('override_database'),
3132            password=d.get('password'),
3133            port=d.get('port'),
3134            port_override=d.get('port_override'),
3135            secret_store_id=d.get('secret_store_id'),
3136            tags=d.get('tags'),
3137            username=d.get('username'),
3138        )
AzurePostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3032    def __init__(
3033        self,
3034        bind_interface=None,
3035        database=None,
3036        egress_filter=None,
3037        healthy=None,
3038        hostname=None,
3039        id=None,
3040        name=None,
3041        override_database=None,
3042        password=None,
3043        port=None,
3044        port_override=None,
3045        secret_store_id=None,
3046        tags=None,
3047        username=None,
3048    ):
3049        self.bind_interface = bind_interface if bind_interface is not None else ''
3050        '''
3051         Bind interface
3052        '''
3053        self.database = database if database is not None else ''
3054        self.egress_filter = egress_filter if egress_filter is not None else ''
3055        '''
3056         A filter applied to the routing logic to pin datasource to nodes.
3057        '''
3058        self.healthy = healthy if healthy is not None else False
3059        '''
3060         True if the datasource is reachable and the credentials are valid.
3061        '''
3062        self.hostname = hostname if hostname is not None else ''
3063        self.id = id if id is not None else ''
3064        '''
3065         Unique identifier of the Resource.
3066        '''
3067        self.name = name if name is not None else ''
3068        '''
3069         Unique human-readable name of the Resource.
3070        '''
3071        self.override_database = override_database if override_database is not None else False
3072        self.password = password if password is not None else ''
3073        self.port = port if port is not None else 0
3074        self.port_override = port_override if port_override is not None else 0
3075        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3076        '''
3077         ID of the secret store containing credentials for this resource, if any.
3078        '''
3079        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3080        '''
3081         Tags is a map of key, value pairs.
3082        '''
3083        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3103    def to_dict(self):
3104        return {
3105            'bind_interface': self.bind_interface,
3106            'database': self.database,
3107            'egress_filter': self.egress_filter,
3108            'healthy': self.healthy,
3109            'hostname': self.hostname,
3110            'id': self.id,
3111            'name': self.name,
3112            'override_database': self.override_database,
3113            'password': self.password,
3114            'port': self.port,
3115            'port_override': self.port_override,
3116            'secret_store_id': self.secret_store_id,
3117            'tags': self.tags,
3118            'username': self.username,
3119        }
@classmethod
def from_dict(cls, d)
3121    @classmethod
3122    def from_dict(cls, d):
3123        return cls(
3124            bind_interface=d.get('bind_interface'),
3125            database=d.get('database'),
3126            egress_filter=d.get('egress_filter'),
3127            healthy=d.get('healthy'),
3128            hostname=d.get('hostname'),
3129            id=d.get('id'),
3130            name=d.get('name'),
3131            override_database=d.get('override_database'),
3132            password=d.get('password'),
3133            port=d.get('port'),
3134            port_override=d.get('port_override'),
3135            secret_store_id=d.get('secret_store_id'),
3136            tags=d.get('tags'),
3137            username=d.get('username'),
3138        )
class AzureStore:
3141class AzureStore:
3142    __slots__ = [
3143        'id',
3144        'name',
3145        'tags',
3146        'vault_uri',
3147    ]
3148
3149    def __init__(
3150        self,
3151        id=None,
3152        name=None,
3153        tags=None,
3154        vault_uri=None,
3155    ):
3156        self.id = id if id is not None else ''
3157        '''
3158         Unique identifier of the SecretStore.
3159        '''
3160        self.name = name if name is not None else ''
3161        '''
3162         Unique human-readable name of the SecretStore.
3163        '''
3164        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3165        '''
3166         Tags is a map of key, value pairs.
3167        '''
3168        self.vault_uri = vault_uri if vault_uri is not None else ''
3169
3170    def __repr__(self):
3171        return '<sdm.AzureStore ' + \
3172            'id: ' + repr(self.id) + ' ' +\
3173            'name: ' + repr(self.name) + ' ' +\
3174            'tags: ' + repr(self.tags) + ' ' +\
3175            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
3176            '>'
3177
3178    def to_dict(self):
3179        return {
3180            'id': self.id,
3181            'name': self.name,
3182            'tags': self.tags,
3183            'vault_uri': self.vault_uri,
3184        }
3185
3186    @classmethod
3187    def from_dict(cls, d):
3188        return cls(
3189            id=d.get('id'),
3190            name=d.get('name'),
3191            tags=d.get('tags'),
3192            vault_uri=d.get('vault_uri'),
3193        )
AzureStore(id=None, name=None, tags=None, vault_uri=None)
3149    def __init__(
3150        self,
3151        id=None,
3152        name=None,
3153        tags=None,
3154        vault_uri=None,
3155    ):
3156        self.id = id if id is not None else ''
3157        '''
3158         Unique identifier of the SecretStore.
3159        '''
3160        self.name = name if name is not None else ''
3161        '''
3162         Unique human-readable name of the SecretStore.
3163        '''
3164        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3165        '''
3166         Tags is a map of key, value pairs.
3167        '''
3168        self.vault_uri = vault_uri if vault_uri is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

vault_uri
def to_dict(self)
3178    def to_dict(self):
3179        return {
3180            'id': self.id,
3181            'name': self.name,
3182            'tags': self.tags,
3183            'vault_uri': self.vault_uri,
3184        }
@classmethod
def from_dict(cls, d)
3186    @classmethod
3187    def from_dict(cls, d):
3188        return cls(
3189            id=d.get('id'),
3190            name=d.get('name'),
3191            tags=d.get('tags'),
3192            vault_uri=d.get('vault_uri'),
3193        )
class BigQuery:
3196class BigQuery:
3197    __slots__ = [
3198        'bind_interface',
3199        'egress_filter',
3200        'endpoint',
3201        'healthy',
3202        'id',
3203        'name',
3204        'port_override',
3205        'private_key',
3206        'project',
3207        'secret_store_id',
3208        'tags',
3209        'username',
3210    ]
3211
3212    def __init__(
3213        self,
3214        bind_interface=None,
3215        egress_filter=None,
3216        endpoint=None,
3217        healthy=None,
3218        id=None,
3219        name=None,
3220        port_override=None,
3221        private_key=None,
3222        project=None,
3223        secret_store_id=None,
3224        tags=None,
3225        username=None,
3226    ):
3227        self.bind_interface = bind_interface if bind_interface is not None else ''
3228        '''
3229         Bind interface
3230        '''
3231        self.egress_filter = egress_filter if egress_filter is not None else ''
3232        '''
3233         A filter applied to the routing logic to pin datasource to nodes.
3234        '''
3235        self.endpoint = endpoint if endpoint is not None else ''
3236        self.healthy = healthy if healthy is not None else False
3237        '''
3238         True if the datasource is reachable and the credentials are valid.
3239        '''
3240        self.id = id if id is not None else ''
3241        '''
3242         Unique identifier of the Resource.
3243        '''
3244        self.name = name if name is not None else ''
3245        '''
3246         Unique human-readable name of the Resource.
3247        '''
3248        self.port_override = port_override if port_override is not None else 0
3249        self.private_key = private_key if private_key is not None else ''
3250        self.project = project if project is not None else ''
3251        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3252        '''
3253         ID of the secret store containing credentials for this resource, if any.
3254        '''
3255        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3256        '''
3257         Tags is a map of key, value pairs.
3258        '''
3259        self.username = username if username is not None else ''
3260
3261    def __repr__(self):
3262        return '<sdm.BigQuery ' + \
3263            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3264            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3265            'endpoint: ' + repr(self.endpoint) + ' ' +\
3266            'healthy: ' + repr(self.healthy) + ' ' +\
3267            'id: ' + repr(self.id) + ' ' +\
3268            'name: ' + repr(self.name) + ' ' +\
3269            'port_override: ' + repr(self.port_override) + ' ' +\
3270            'private_key: ' + repr(self.private_key) + ' ' +\
3271            'project: ' + repr(self.project) + ' ' +\
3272            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3273            'tags: ' + repr(self.tags) + ' ' +\
3274            'username: ' + repr(self.username) + ' ' +\
3275            '>'
3276
3277    def to_dict(self):
3278        return {
3279            'bind_interface': self.bind_interface,
3280            'egress_filter': self.egress_filter,
3281            'endpoint': self.endpoint,
3282            'healthy': self.healthy,
3283            'id': self.id,
3284            'name': self.name,
3285            'port_override': self.port_override,
3286            'private_key': self.private_key,
3287            'project': self.project,
3288            'secret_store_id': self.secret_store_id,
3289            'tags': self.tags,
3290            'username': self.username,
3291        }
3292
3293    @classmethod
3294    def from_dict(cls, d):
3295        return cls(
3296            bind_interface=d.get('bind_interface'),
3297            egress_filter=d.get('egress_filter'),
3298            endpoint=d.get('endpoint'),
3299            healthy=d.get('healthy'),
3300            id=d.get('id'),
3301            name=d.get('name'),
3302            port_override=d.get('port_override'),
3303            private_key=d.get('private_key'),
3304            project=d.get('project'),
3305            secret_store_id=d.get('secret_store_id'),
3306            tags=d.get('tags'),
3307            username=d.get('username'),
3308        )
BigQuery( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None)
3212    def __init__(
3213        self,
3214        bind_interface=None,
3215        egress_filter=None,
3216        endpoint=None,
3217        healthy=None,
3218        id=None,
3219        name=None,
3220        port_override=None,
3221        private_key=None,
3222        project=None,
3223        secret_store_id=None,
3224        tags=None,
3225        username=None,
3226    ):
3227        self.bind_interface = bind_interface if bind_interface is not None else ''
3228        '''
3229         Bind interface
3230        '''
3231        self.egress_filter = egress_filter if egress_filter is not None else ''
3232        '''
3233         A filter applied to the routing logic to pin datasource to nodes.
3234        '''
3235        self.endpoint = endpoint if endpoint is not None else ''
3236        self.healthy = healthy if healthy is not None else False
3237        '''
3238         True if the datasource is reachable and the credentials are valid.
3239        '''
3240        self.id = id if id is not None else ''
3241        '''
3242         Unique identifier of the Resource.
3243        '''
3244        self.name = name if name is not None else ''
3245        '''
3246         Unique human-readable name of the Resource.
3247        '''
3248        self.port_override = port_override if port_override is not None else 0
3249        self.private_key = private_key if private_key is not None else ''
3250        self.project = project if project is not None else ''
3251        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3252        '''
3253         ID of the secret store containing credentials for this resource, if any.
3254        '''
3255        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3256        '''
3257         Tags is a map of key, value pairs.
3258        '''
3259        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
private_key
project
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3277    def to_dict(self):
3278        return {
3279            'bind_interface': self.bind_interface,
3280            'egress_filter': self.egress_filter,
3281            'endpoint': self.endpoint,
3282            'healthy': self.healthy,
3283            'id': self.id,
3284            'name': self.name,
3285            'port_override': self.port_override,
3286            'private_key': self.private_key,
3287            'project': self.project,
3288            'secret_store_id': self.secret_store_id,
3289            'tags': self.tags,
3290            'username': self.username,
3291        }
@classmethod
def from_dict(cls, d)
3293    @classmethod
3294    def from_dict(cls, d):
3295        return cls(
3296            bind_interface=d.get('bind_interface'),
3297            egress_filter=d.get('egress_filter'),
3298            endpoint=d.get('endpoint'),
3299            healthy=d.get('healthy'),
3300            id=d.get('id'),
3301            name=d.get('name'),
3302            port_override=d.get('port_override'),
3303            private_key=d.get('private_key'),
3304            project=d.get('project'),
3305            secret_store_id=d.get('secret_store_id'),
3306            tags=d.get('tags'),
3307            username=d.get('username'),
3308        )
class Cassandra:
3311class Cassandra:
3312    __slots__ = [
3313        'bind_interface',
3314        'egress_filter',
3315        'healthy',
3316        'hostname',
3317        'id',
3318        'name',
3319        'password',
3320        'port',
3321        'port_override',
3322        'secret_store_id',
3323        'tags',
3324        'tls_required',
3325        'username',
3326    ]
3327
3328    def __init__(
3329        self,
3330        bind_interface=None,
3331        egress_filter=None,
3332        healthy=None,
3333        hostname=None,
3334        id=None,
3335        name=None,
3336        password=None,
3337        port=None,
3338        port_override=None,
3339        secret_store_id=None,
3340        tags=None,
3341        tls_required=None,
3342        username=None,
3343    ):
3344        self.bind_interface = bind_interface if bind_interface is not None else ''
3345        '''
3346         Bind interface
3347        '''
3348        self.egress_filter = egress_filter if egress_filter is not None else ''
3349        '''
3350         A filter applied to the routing logic to pin datasource to nodes.
3351        '''
3352        self.healthy = healthy if healthy is not None else False
3353        '''
3354         True if the datasource is reachable and the credentials are valid.
3355        '''
3356        self.hostname = hostname if hostname is not None else ''
3357        self.id = id if id is not None else ''
3358        '''
3359         Unique identifier of the Resource.
3360        '''
3361        self.name = name if name is not None else ''
3362        '''
3363         Unique human-readable name of the Resource.
3364        '''
3365        self.password = password if password is not None else ''
3366        self.port = port if port is not None else 0
3367        self.port_override = port_override if port_override is not None else 0
3368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3369        '''
3370         ID of the secret store containing credentials for this resource, if any.
3371        '''
3372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3373        '''
3374         Tags is a map of key, value pairs.
3375        '''
3376        self.tls_required = tls_required if tls_required is not None else False
3377        self.username = username if username is not None else ''
3378
3379    def __repr__(self):
3380        return '<sdm.Cassandra ' + \
3381            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3382            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3383            'healthy: ' + repr(self.healthy) + ' ' +\
3384            'hostname: ' + repr(self.hostname) + ' ' +\
3385            'id: ' + repr(self.id) + ' ' +\
3386            'name: ' + repr(self.name) + ' ' +\
3387            'password: ' + repr(self.password) + ' ' +\
3388            'port: ' + repr(self.port) + ' ' +\
3389            'port_override: ' + repr(self.port_override) + ' ' +\
3390            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3391            'tags: ' + repr(self.tags) + ' ' +\
3392            'tls_required: ' + repr(self.tls_required) + ' ' +\
3393            'username: ' + repr(self.username) + ' ' +\
3394            '>'
3395
3396    def to_dict(self):
3397        return {
3398            'bind_interface': self.bind_interface,
3399            'egress_filter': self.egress_filter,
3400            'healthy': self.healthy,
3401            'hostname': self.hostname,
3402            'id': self.id,
3403            'name': self.name,
3404            'password': self.password,
3405            'port': self.port,
3406            'port_override': self.port_override,
3407            'secret_store_id': self.secret_store_id,
3408            'tags': self.tags,
3409            'tls_required': self.tls_required,
3410            'username': self.username,
3411        }
3412
3413    @classmethod
3414    def from_dict(cls, d):
3415        return cls(
3416            bind_interface=d.get('bind_interface'),
3417            egress_filter=d.get('egress_filter'),
3418            healthy=d.get('healthy'),
3419            hostname=d.get('hostname'),
3420            id=d.get('id'),
3421            name=d.get('name'),
3422            password=d.get('password'),
3423            port=d.get('port'),
3424            port_override=d.get('port_override'),
3425            secret_store_id=d.get('secret_store_id'),
3426            tags=d.get('tags'),
3427            tls_required=d.get('tls_required'),
3428            username=d.get('username'),
3429        )
Cassandra( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3328    def __init__(
3329        self,
3330        bind_interface=None,
3331        egress_filter=None,
3332        healthy=None,
3333        hostname=None,
3334        id=None,
3335        name=None,
3336        password=None,
3337        port=None,
3338        port_override=None,
3339        secret_store_id=None,
3340        tags=None,
3341        tls_required=None,
3342        username=None,
3343    ):
3344        self.bind_interface = bind_interface if bind_interface is not None else ''
3345        '''
3346         Bind interface
3347        '''
3348        self.egress_filter = egress_filter if egress_filter is not None else ''
3349        '''
3350         A filter applied to the routing logic to pin datasource to nodes.
3351        '''
3352        self.healthy = healthy if healthy is not None else False
3353        '''
3354         True if the datasource is reachable and the credentials are valid.
3355        '''
3356        self.hostname = hostname if hostname is not None else ''
3357        self.id = id if id is not None else ''
3358        '''
3359         Unique identifier of the Resource.
3360        '''
3361        self.name = name if name is not None else ''
3362        '''
3363         Unique human-readable name of the Resource.
3364        '''
3365        self.password = password if password is not None else ''
3366        self.port = port if port is not None else 0
3367        self.port_override = port_override if port_override is not None else 0
3368        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3369        '''
3370         ID of the secret store containing credentials for this resource, if any.
3371        '''
3372        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3373        '''
3374         Tags is a map of key, value pairs.
3375        '''
3376        self.tls_required = tls_required if tls_required is not None else False
3377        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
3396    def to_dict(self):
3397        return {
3398            'bind_interface': self.bind_interface,
3399            'egress_filter': self.egress_filter,
3400            'healthy': self.healthy,
3401            'hostname': self.hostname,
3402            'id': self.id,
3403            'name': self.name,
3404            'password': self.password,
3405            'port': self.port,
3406            'port_override': self.port_override,
3407            'secret_store_id': self.secret_store_id,
3408            'tags': self.tags,
3409            'tls_required': self.tls_required,
3410            'username': self.username,
3411        }
@classmethod
def from_dict(cls, d)
3413    @classmethod
3414    def from_dict(cls, d):
3415        return cls(
3416            bind_interface=d.get('bind_interface'),
3417            egress_filter=d.get('egress_filter'),
3418            healthy=d.get('healthy'),
3419            hostname=d.get('hostname'),
3420            id=d.get('id'),
3421            name=d.get('name'),
3422            password=d.get('password'),
3423            port=d.get('port'),
3424            port_override=d.get('port_override'),
3425            secret_store_id=d.get('secret_store_id'),
3426            tags=d.get('tags'),
3427            tls_required=d.get('tls_required'),
3428            username=d.get('username'),
3429        )
class Citus:
3432class Citus:
3433    __slots__ = [
3434        'bind_interface',
3435        'database',
3436        'egress_filter',
3437        'healthy',
3438        'hostname',
3439        'id',
3440        'name',
3441        'override_database',
3442        'password',
3443        'port',
3444        'port_override',
3445        'secret_store_id',
3446        'tags',
3447        'username',
3448    ]
3449
3450    def __init__(
3451        self,
3452        bind_interface=None,
3453        database=None,
3454        egress_filter=None,
3455        healthy=None,
3456        hostname=None,
3457        id=None,
3458        name=None,
3459        override_database=None,
3460        password=None,
3461        port=None,
3462        port_override=None,
3463        secret_store_id=None,
3464        tags=None,
3465        username=None,
3466    ):
3467        self.bind_interface = bind_interface if bind_interface is not None else ''
3468        '''
3469         Bind interface
3470        '''
3471        self.database = database if database is not None else ''
3472        self.egress_filter = egress_filter if egress_filter is not None else ''
3473        '''
3474         A filter applied to the routing logic to pin datasource to nodes.
3475        '''
3476        self.healthy = healthy if healthy is not None else False
3477        '''
3478         True if the datasource is reachable and the credentials are valid.
3479        '''
3480        self.hostname = hostname if hostname is not None else ''
3481        self.id = id if id is not None else ''
3482        '''
3483         Unique identifier of the Resource.
3484        '''
3485        self.name = name if name is not None else ''
3486        '''
3487         Unique human-readable name of the Resource.
3488        '''
3489        self.override_database = override_database if override_database is not None else False
3490        self.password = password if password is not None else ''
3491        self.port = port if port is not None else 0
3492        self.port_override = port_override if port_override is not None else 0
3493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3494        '''
3495         ID of the secret store containing credentials for this resource, if any.
3496        '''
3497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3498        '''
3499         Tags is a map of key, value pairs.
3500        '''
3501        self.username = username if username is not None else ''
3502
3503    def __repr__(self):
3504        return '<sdm.Citus ' + \
3505            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3506            'database: ' + repr(self.database) + ' ' +\
3507            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3508            'healthy: ' + repr(self.healthy) + ' ' +\
3509            'hostname: ' + repr(self.hostname) + ' ' +\
3510            'id: ' + repr(self.id) + ' ' +\
3511            'name: ' + repr(self.name) + ' ' +\
3512            'override_database: ' + repr(self.override_database) + ' ' +\
3513            'password: ' + repr(self.password) + ' ' +\
3514            'port: ' + repr(self.port) + ' ' +\
3515            'port_override: ' + repr(self.port_override) + ' ' +\
3516            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3517            'tags: ' + repr(self.tags) + ' ' +\
3518            'username: ' + repr(self.username) + ' ' +\
3519            '>'
3520
3521    def to_dict(self):
3522        return {
3523            'bind_interface': self.bind_interface,
3524            'database': self.database,
3525            'egress_filter': self.egress_filter,
3526            'healthy': self.healthy,
3527            'hostname': self.hostname,
3528            'id': self.id,
3529            'name': self.name,
3530            'override_database': self.override_database,
3531            'password': self.password,
3532            'port': self.port,
3533            'port_override': self.port_override,
3534            'secret_store_id': self.secret_store_id,
3535            'tags': self.tags,
3536            'username': self.username,
3537        }
3538
3539    @classmethod
3540    def from_dict(cls, d):
3541        return cls(
3542            bind_interface=d.get('bind_interface'),
3543            database=d.get('database'),
3544            egress_filter=d.get('egress_filter'),
3545            healthy=d.get('healthy'),
3546            hostname=d.get('hostname'),
3547            id=d.get('id'),
3548            name=d.get('name'),
3549            override_database=d.get('override_database'),
3550            password=d.get('password'),
3551            port=d.get('port'),
3552            port_override=d.get('port_override'),
3553            secret_store_id=d.get('secret_store_id'),
3554            tags=d.get('tags'),
3555            username=d.get('username'),
3556        )
Citus( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3450    def __init__(
3451        self,
3452        bind_interface=None,
3453        database=None,
3454        egress_filter=None,
3455        healthy=None,
3456        hostname=None,
3457        id=None,
3458        name=None,
3459        override_database=None,
3460        password=None,
3461        port=None,
3462        port_override=None,
3463        secret_store_id=None,
3464        tags=None,
3465        username=None,
3466    ):
3467        self.bind_interface = bind_interface if bind_interface is not None else ''
3468        '''
3469         Bind interface
3470        '''
3471        self.database = database if database is not None else ''
3472        self.egress_filter = egress_filter if egress_filter is not None else ''
3473        '''
3474         A filter applied to the routing logic to pin datasource to nodes.
3475        '''
3476        self.healthy = healthy if healthy is not None else False
3477        '''
3478         True if the datasource is reachable and the credentials are valid.
3479        '''
3480        self.hostname = hostname if hostname is not None else ''
3481        self.id = id if id is not None else ''
3482        '''
3483         Unique identifier of the Resource.
3484        '''
3485        self.name = name if name is not None else ''
3486        '''
3487         Unique human-readable name of the Resource.
3488        '''
3489        self.override_database = override_database if override_database is not None else False
3490        self.password = password if password is not None else ''
3491        self.port = port if port is not None else 0
3492        self.port_override = port_override if port_override is not None else 0
3493        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3494        '''
3495         ID of the secret store containing credentials for this resource, if any.
3496        '''
3497        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3498        '''
3499         Tags is a map of key, value pairs.
3500        '''
3501        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3521    def to_dict(self):
3522        return {
3523            'bind_interface': self.bind_interface,
3524            'database': self.database,
3525            'egress_filter': self.egress_filter,
3526            'healthy': self.healthy,
3527            'hostname': self.hostname,
3528            'id': self.id,
3529            'name': self.name,
3530            'override_database': self.override_database,
3531            'password': self.password,
3532            'port': self.port,
3533            'port_override': self.port_override,
3534            'secret_store_id': self.secret_store_id,
3535            'tags': self.tags,
3536            'username': self.username,
3537        }
@classmethod
def from_dict(cls, d)
3539    @classmethod
3540    def from_dict(cls, d):
3541        return cls(
3542            bind_interface=d.get('bind_interface'),
3543            database=d.get('database'),
3544            egress_filter=d.get('egress_filter'),
3545            healthy=d.get('healthy'),
3546            hostname=d.get('hostname'),
3547            id=d.get('id'),
3548            name=d.get('name'),
3549            override_database=d.get('override_database'),
3550            password=d.get('password'),
3551            port=d.get('port'),
3552            port_override=d.get('port_override'),
3553            secret_store_id=d.get('secret_store_id'),
3554            tags=d.get('tags'),
3555            username=d.get('username'),
3556        )
class Clustrix:
3559class Clustrix:
3560    __slots__ = [
3561        'bind_interface',
3562        'database',
3563        'egress_filter',
3564        'healthy',
3565        'hostname',
3566        'id',
3567        'name',
3568        'password',
3569        'port',
3570        'port_override',
3571        'secret_store_id',
3572        'tags',
3573        'username',
3574    ]
3575
3576    def __init__(
3577        self,
3578        bind_interface=None,
3579        database=None,
3580        egress_filter=None,
3581        healthy=None,
3582        hostname=None,
3583        id=None,
3584        name=None,
3585        password=None,
3586        port=None,
3587        port_override=None,
3588        secret_store_id=None,
3589        tags=None,
3590        username=None,
3591    ):
3592        self.bind_interface = bind_interface if bind_interface is not None else ''
3593        '''
3594         Bind interface
3595        '''
3596        self.database = database if database is not None else ''
3597        self.egress_filter = egress_filter if egress_filter is not None else ''
3598        '''
3599         A filter applied to the routing logic to pin datasource to nodes.
3600        '''
3601        self.healthy = healthy if healthy is not None else False
3602        '''
3603         True if the datasource is reachable and the credentials are valid.
3604        '''
3605        self.hostname = hostname if hostname is not None else ''
3606        self.id = id if id is not None else ''
3607        '''
3608         Unique identifier of the Resource.
3609        '''
3610        self.name = name if name is not None else ''
3611        '''
3612         Unique human-readable name of the Resource.
3613        '''
3614        self.password = password if password is not None else ''
3615        self.port = port if port is not None else 0
3616        self.port_override = port_override if port_override is not None else 0
3617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3618        '''
3619         ID of the secret store containing credentials for this resource, if any.
3620        '''
3621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3622        '''
3623         Tags is a map of key, value pairs.
3624        '''
3625        self.username = username if username is not None else ''
3626
3627    def __repr__(self):
3628        return '<sdm.Clustrix ' + \
3629            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3630            'database: ' + repr(self.database) + ' ' +\
3631            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3632            'healthy: ' + repr(self.healthy) + ' ' +\
3633            'hostname: ' + repr(self.hostname) + ' ' +\
3634            'id: ' + repr(self.id) + ' ' +\
3635            'name: ' + repr(self.name) + ' ' +\
3636            'password: ' + repr(self.password) + ' ' +\
3637            'port: ' + repr(self.port) + ' ' +\
3638            'port_override: ' + repr(self.port_override) + ' ' +\
3639            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3640            'tags: ' + repr(self.tags) + ' ' +\
3641            'username: ' + repr(self.username) + ' ' +\
3642            '>'
3643
3644    def to_dict(self):
3645        return {
3646            'bind_interface': self.bind_interface,
3647            'database': self.database,
3648            'egress_filter': self.egress_filter,
3649            'healthy': self.healthy,
3650            'hostname': self.hostname,
3651            'id': self.id,
3652            'name': self.name,
3653            'password': self.password,
3654            'port': self.port,
3655            'port_override': self.port_override,
3656            'secret_store_id': self.secret_store_id,
3657            'tags': self.tags,
3658            'username': self.username,
3659        }
3660
3661    @classmethod
3662    def from_dict(cls, d):
3663        return cls(
3664            bind_interface=d.get('bind_interface'),
3665            database=d.get('database'),
3666            egress_filter=d.get('egress_filter'),
3667            healthy=d.get('healthy'),
3668            hostname=d.get('hostname'),
3669            id=d.get('id'),
3670            name=d.get('name'),
3671            password=d.get('password'),
3672            port=d.get('port'),
3673            port_override=d.get('port_override'),
3674            secret_store_id=d.get('secret_store_id'),
3675            tags=d.get('tags'),
3676            username=d.get('username'),
3677        )
Clustrix( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3576    def __init__(
3577        self,
3578        bind_interface=None,
3579        database=None,
3580        egress_filter=None,
3581        healthy=None,
3582        hostname=None,
3583        id=None,
3584        name=None,
3585        password=None,
3586        port=None,
3587        port_override=None,
3588        secret_store_id=None,
3589        tags=None,
3590        username=None,
3591    ):
3592        self.bind_interface = bind_interface if bind_interface is not None else ''
3593        '''
3594         Bind interface
3595        '''
3596        self.database = database if database is not None else ''
3597        self.egress_filter = egress_filter if egress_filter is not None else ''
3598        '''
3599         A filter applied to the routing logic to pin datasource to nodes.
3600        '''
3601        self.healthy = healthy if healthy is not None else False
3602        '''
3603         True if the datasource is reachable and the credentials are valid.
3604        '''
3605        self.hostname = hostname if hostname is not None else ''
3606        self.id = id if id is not None else ''
3607        '''
3608         Unique identifier of the Resource.
3609        '''
3610        self.name = name if name is not None else ''
3611        '''
3612         Unique human-readable name of the Resource.
3613        '''
3614        self.password = password if password is not None else ''
3615        self.port = port if port is not None else 0
3616        self.port_override = port_override if port_override is not None else 0
3617        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3618        '''
3619         ID of the secret store containing credentials for this resource, if any.
3620        '''
3621        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3622        '''
3623         Tags is a map of key, value pairs.
3624        '''
3625        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3644    def to_dict(self):
3645        return {
3646            'bind_interface': self.bind_interface,
3647            'database': self.database,
3648            'egress_filter': self.egress_filter,
3649            'healthy': self.healthy,
3650            'hostname': self.hostname,
3651            'id': self.id,
3652            'name': self.name,
3653            'password': self.password,
3654            'port': self.port,
3655            'port_override': self.port_override,
3656            'secret_store_id': self.secret_store_id,
3657            'tags': self.tags,
3658            'username': self.username,
3659        }
@classmethod
def from_dict(cls, d)
3661    @classmethod
3662    def from_dict(cls, d):
3663        return cls(
3664            bind_interface=d.get('bind_interface'),
3665            database=d.get('database'),
3666            egress_filter=d.get('egress_filter'),
3667            healthy=d.get('healthy'),
3668            hostname=d.get('hostname'),
3669            id=d.get('id'),
3670            name=d.get('name'),
3671            password=d.get('password'),
3672            port=d.get('port'),
3673            port_override=d.get('port_override'),
3674            secret_store_id=d.get('secret_store_id'),
3675            tags=d.get('tags'),
3676            username=d.get('username'),
3677        )
class Cockroach:
3680class Cockroach:
3681    __slots__ = [
3682        'bind_interface',
3683        'database',
3684        'egress_filter',
3685        'healthy',
3686        'hostname',
3687        'id',
3688        'name',
3689        'override_database',
3690        'password',
3691        'port',
3692        'port_override',
3693        'secret_store_id',
3694        'tags',
3695        'username',
3696    ]
3697
3698    def __init__(
3699        self,
3700        bind_interface=None,
3701        database=None,
3702        egress_filter=None,
3703        healthy=None,
3704        hostname=None,
3705        id=None,
3706        name=None,
3707        override_database=None,
3708        password=None,
3709        port=None,
3710        port_override=None,
3711        secret_store_id=None,
3712        tags=None,
3713        username=None,
3714    ):
3715        self.bind_interface = bind_interface if bind_interface is not None else ''
3716        '''
3717         Bind interface
3718        '''
3719        self.database = database if database is not None else ''
3720        self.egress_filter = egress_filter if egress_filter is not None else ''
3721        '''
3722         A filter applied to the routing logic to pin datasource to nodes.
3723        '''
3724        self.healthy = healthy if healthy is not None else False
3725        '''
3726         True if the datasource is reachable and the credentials are valid.
3727        '''
3728        self.hostname = hostname if hostname is not None else ''
3729        self.id = id if id is not None else ''
3730        '''
3731         Unique identifier of the Resource.
3732        '''
3733        self.name = name if name is not None else ''
3734        '''
3735         Unique human-readable name of the Resource.
3736        '''
3737        self.override_database = override_database if override_database is not None else False
3738        self.password = password if password is not None else ''
3739        self.port = port if port is not None else 0
3740        self.port_override = port_override if port_override is not None else 0
3741        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3742        '''
3743         ID of the secret store containing credentials for this resource, if any.
3744        '''
3745        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3746        '''
3747         Tags is a map of key, value pairs.
3748        '''
3749        self.username = username if username is not None else ''
3750
3751    def __repr__(self):
3752        return '<sdm.Cockroach ' + \
3753            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3754            'database: ' + repr(self.database) + ' ' +\
3755            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3756            'healthy: ' + repr(self.healthy) + ' ' +\
3757            'hostname: ' + repr(self.hostname) + ' ' +\
3758            'id: ' + repr(self.id) + ' ' +\
3759            'name: ' + repr(self.name) + ' ' +\
3760            'override_database: ' + repr(self.override_database) + ' ' +\
3761            'password: ' + repr(self.password) + ' ' +\
3762            'port: ' + repr(self.port) + ' ' +\
3763            'port_override: ' + repr(self.port_override) + ' ' +\
3764            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3765            'tags: ' + repr(self.tags) + ' ' +\
3766            'username: ' + repr(self.username) + ' ' +\
3767            '>'
3768
3769    def to_dict(self):
3770        return {
3771            'bind_interface': self.bind_interface,
3772            'database': self.database,
3773            'egress_filter': self.egress_filter,
3774            'healthy': self.healthy,
3775            'hostname': self.hostname,
3776            'id': self.id,
3777            'name': self.name,
3778            'override_database': self.override_database,
3779            'password': self.password,
3780            'port': self.port,
3781            'port_override': self.port_override,
3782            'secret_store_id': self.secret_store_id,
3783            'tags': self.tags,
3784            'username': self.username,
3785        }
3786
3787    @classmethod
3788    def from_dict(cls, d):
3789        return cls(
3790            bind_interface=d.get('bind_interface'),
3791            database=d.get('database'),
3792            egress_filter=d.get('egress_filter'),
3793            healthy=d.get('healthy'),
3794            hostname=d.get('hostname'),
3795            id=d.get('id'),
3796            name=d.get('name'),
3797            override_database=d.get('override_database'),
3798            password=d.get('password'),
3799            port=d.get('port'),
3800            port_override=d.get('port_override'),
3801            secret_store_id=d.get('secret_store_id'),
3802            tags=d.get('tags'),
3803            username=d.get('username'),
3804        )
Cockroach( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3698    def __init__(
3699        self,
3700        bind_interface=None,
3701        database=None,
3702        egress_filter=None,
3703        healthy=None,
3704        hostname=None,
3705        id=None,
3706        name=None,
3707        override_database=None,
3708        password=None,
3709        port=None,
3710        port_override=None,
3711        secret_store_id=None,
3712        tags=None,
3713        username=None,
3714    ):
3715        self.bind_interface = bind_interface if bind_interface is not None else ''
3716        '''
3717         Bind interface
3718        '''
3719        self.database = database if database is not None else ''
3720        self.egress_filter = egress_filter if egress_filter is not None else ''
3721        '''
3722         A filter applied to the routing logic to pin datasource to nodes.
3723        '''
3724        self.healthy = healthy if healthy is not None else False
3725        '''
3726         True if the datasource is reachable and the credentials are valid.
3727        '''
3728        self.hostname = hostname if hostname is not None else ''
3729        self.id = id if id is not None else ''
3730        '''
3731         Unique identifier of the Resource.
3732        '''
3733        self.name = name if name is not None else ''
3734        '''
3735         Unique human-readable name of the Resource.
3736        '''
3737        self.override_database = override_database if override_database is not None else False
3738        self.password = password if password is not None else ''
3739        self.port = port if port is not None else 0
3740        self.port_override = port_override if port_override is not None else 0
3741        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3742        '''
3743         ID of the secret store containing credentials for this resource, if any.
3744        '''
3745        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3746        '''
3747         Tags is a map of key, value pairs.
3748        '''
3749        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3769    def to_dict(self):
3770        return {
3771            'bind_interface': self.bind_interface,
3772            'database': self.database,
3773            'egress_filter': self.egress_filter,
3774            'healthy': self.healthy,
3775            'hostname': self.hostname,
3776            'id': self.id,
3777            'name': self.name,
3778            'override_database': self.override_database,
3779            'password': self.password,
3780            'port': self.port,
3781            'port_override': self.port_override,
3782            'secret_store_id': self.secret_store_id,
3783            'tags': self.tags,
3784            'username': self.username,
3785        }
@classmethod
def from_dict(cls, d)
3787    @classmethod
3788    def from_dict(cls, d):
3789        return cls(
3790            bind_interface=d.get('bind_interface'),
3791            database=d.get('database'),
3792            egress_filter=d.get('egress_filter'),
3793            healthy=d.get('healthy'),
3794            hostname=d.get('hostname'),
3795            id=d.get('id'),
3796            name=d.get('name'),
3797            override_database=d.get('override_database'),
3798            password=d.get('password'),
3799            port=d.get('port'),
3800            port_override=d.get('port_override'),
3801            secret_store_id=d.get('secret_store_id'),
3802            tags=d.get('tags'),
3803            username=d.get('username'),
3804        )
class ControlPanelGetSSHCAPublicKeyResponse:
3807class ControlPanelGetSSHCAPublicKeyResponse:
3808    '''
3809         ControlPanelGetSSHCAPublicKeyResponse represents a request for an
3810     organization's SSH Certificate Authority public key.
3811    '''
3812    __slots__ = [
3813        'meta',
3814        'public_key',
3815        'rate_limit',
3816    ]
3817
3818    def __init__(
3819        self,
3820        meta=None,
3821        public_key=None,
3822        rate_limit=None,
3823    ):
3824        self.meta = meta if meta is not None else None
3825        '''
3826         Reserved for future use.
3827        '''
3828        self.public_key = public_key if public_key is not None else ''
3829        '''
3830         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3831         key format.
3832        '''
3833        self.rate_limit = rate_limit if rate_limit is not None else None
3834        '''
3835         Rate limit information.
3836        '''
3837
3838    def __repr__(self):
3839        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
3840            'meta: ' + repr(self.meta) + ' ' +\
3841            'public_key: ' + repr(self.public_key) + ' ' +\
3842            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3843            '>'
3844
3845    def to_dict(self):
3846        return {
3847            'meta': self.meta,
3848            'public_key': self.public_key,
3849            'rate_limit': self.rate_limit,
3850        }
3851
3852    @classmethod
3853    def from_dict(cls, d):
3854        return cls(
3855            meta=d.get('meta'),
3856            public_key=d.get('public_key'),
3857            rate_limit=d.get('rate_limit'),
3858        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
3818    def __init__(
3819        self,
3820        meta=None,
3821        public_key=None,
3822        rate_limit=None,
3823    ):
3824        self.meta = meta if meta is not None else None
3825        '''
3826         Reserved for future use.
3827        '''
3828        self.public_key = public_key if public_key is not None else ''
3829        '''
3830         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3831         key format.
3832        '''
3833        self.rate_limit = rate_limit if rate_limit is not None else None
3834        '''
3835         Rate limit information.
3836        '''
meta

Reserved for future use.

public_key

The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.

rate_limit

Rate limit information.

def to_dict(self)
3845    def to_dict(self):
3846        return {
3847            'meta': self.meta,
3848            'public_key': self.public_key,
3849            'rate_limit': self.rate_limit,
3850        }
@classmethod
def from_dict(cls, d)
3852    @classmethod
3853    def from_dict(cls, d):
3854        return cls(
3855            meta=d.get('meta'),
3856            public_key=d.get('public_key'),
3857            rate_limit=d.get('rate_limit'),
3858        )
class ControlPanelVerifyJWTResponse:
3861class ControlPanelVerifyJWTResponse:
3862    '''
3863         ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
3864    '''
3865    __slots__ = [
3866        'meta',
3867        'rate_limit',
3868        'valid',
3869    ]
3870
3871    def __init__(
3872        self,
3873        meta=None,
3874        rate_limit=None,
3875        valid=None,
3876    ):
3877        self.meta = meta if meta is not None else None
3878        '''
3879         Reserved for future use.
3880        '''
3881        self.rate_limit = rate_limit if rate_limit is not None else None
3882        '''
3883         Rate limit information.
3884        '''
3885        self.valid = valid if valid is not None else False
3886        '''
3887         Reports if the given token is valid.
3888        '''
3889
3890    def __repr__(self):
3891        return '<sdm.ControlPanelVerifyJWTResponse ' + \
3892            'meta: ' + repr(self.meta) + ' ' +\
3893            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3894            'valid: ' + repr(self.valid) + ' ' +\
3895            '>'
3896
3897    def to_dict(self):
3898        return {
3899            'meta': self.meta,
3900            'rate_limit': self.rate_limit,
3901            'valid': self.valid,
3902        }
3903
3904    @classmethod
3905    def from_dict(cls, d):
3906        return cls(
3907            meta=d.get('meta'),
3908            rate_limit=d.get('rate_limit'),
3909            valid=d.get('valid'),
3910        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
3871    def __init__(
3872        self,
3873        meta=None,
3874        rate_limit=None,
3875        valid=None,
3876    ):
3877        self.meta = meta if meta is not None else None
3878        '''
3879         Reserved for future use.
3880        '''
3881        self.rate_limit = rate_limit if rate_limit is not None else None
3882        '''
3883         Rate limit information.
3884        '''
3885        self.valid = valid if valid is not None else False
3886        '''
3887         Reports if the given token is valid.
3888        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

valid

Reports if the given token is valid.

def to_dict(self)
3897    def to_dict(self):
3898        return {
3899            'meta': self.meta,
3900            'rate_limit': self.rate_limit,
3901            'valid': self.valid,
3902        }
@classmethod
def from_dict(cls, d)
3904    @classmethod
3905    def from_dict(cls, d):
3906        return cls(
3907            meta=d.get('meta'),
3908            rate_limit=d.get('rate_limit'),
3909            valid=d.get('valid'),
3910        )
class CreateResponseMetadata:
3913class CreateResponseMetadata:
3914    '''
3915         CreateResponseMetadata is reserved for future use.
3916    '''
3917    __slots__ = []
3918
3919    def __init__(self, ):
3920        pass
3921
3922    def __repr__(self):
3923        return '<sdm.CreateResponseMetadata ' + \
3924            '>'
3925
3926    def to_dict(self):
3927        return {}
3928
3929    @classmethod
3930    def from_dict(cls, d):
3931        return cls()

CreateResponseMetadata is reserved for future use.

CreateResponseMetadata()
3919    def __init__(self, ):
3920        pass
def to_dict(self)
3926    def to_dict(self):
3927        return {}
@classmethod
def from_dict(cls, d)
3929    @classmethod
3930    def from_dict(cls, d):
3931        return cls()
class CyberarkConjurStore:
3934class CyberarkConjurStore:
3935    '''
3936    CyberarkConjurStore is currently unstable, and its API may change, or it may be removed,
3937    without a major version bump.
3938    '''
3939    __slots__ = [
3940        'appurl',
3941        'id',
3942        'name',
3943        'tags',
3944    ]
3945
3946    def __init__(
3947        self,
3948        appurl=None,
3949        id=None,
3950        name=None,
3951        tags=None,
3952    ):
3953        self.appurl = appurl if appurl is not None else ''
3954        self.id = id if id is not None else ''
3955        '''
3956         Unique identifier of the SecretStore.
3957        '''
3958        self.name = name if name is not None else ''
3959        '''
3960         Unique human-readable name of the SecretStore.
3961        '''
3962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3963        '''
3964         Tags is a map of key, value pairs.
3965        '''
3966
3967    def __repr__(self):
3968        return '<sdm.CyberarkConjurStore ' + \
3969            'appurl: ' + repr(self.appurl) + ' ' +\
3970            'id: ' + repr(self.id) + ' ' +\
3971            'name: ' + repr(self.name) + ' ' +\
3972            'tags: ' + repr(self.tags) + ' ' +\
3973            '>'
3974
3975    def to_dict(self):
3976        return {
3977            'appurl': self.appurl,
3978            'id': self.id,
3979            'name': self.name,
3980            'tags': self.tags,
3981        }
3982
3983    @classmethod
3984    def from_dict(cls, d):
3985        return cls(
3986            appurl=d.get('appurl'),
3987            id=d.get('id'),
3988            name=d.get('name'),
3989            tags=d.get('tags'),
3990        )

CyberarkConjurStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

CyberarkConjurStore(appurl=None, id=None, name=None, tags=None)
3946    def __init__(
3947        self,
3948        appurl=None,
3949        id=None,
3950        name=None,
3951        tags=None,
3952    ):
3953        self.appurl = appurl if appurl is not None else ''
3954        self.id = id if id is not None else ''
3955        '''
3956         Unique identifier of the SecretStore.
3957        '''
3958        self.name = name if name is not None else ''
3959        '''
3960         Unique human-readable name of the SecretStore.
3961        '''
3962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3963        '''
3964         Tags is a map of key, value pairs.
3965        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
3975    def to_dict(self):
3976        return {
3977            'appurl': self.appurl,
3978            'id': self.id,
3979            'name': self.name,
3980            'tags': self.tags,
3981        }
@classmethod
def from_dict(cls, d)
3983    @classmethod
3984    def from_dict(cls, d):
3985        return cls(
3986            appurl=d.get('appurl'),
3987            id=d.get('id'),
3988            name=d.get('name'),
3989            tags=d.get('tags'),
3990        )
class CyberarkPAMExperimentalStore:
3993class CyberarkPAMExperimentalStore:
3994    '''
3995    CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed,
3996    without a major version bump.
3997    '''
3998    __slots__ = [
3999        'appurl',
4000        'id',
4001        'name',
4002        'tags',
4003    ]
4004
4005    def __init__(
4006        self,
4007        appurl=None,
4008        id=None,
4009        name=None,
4010        tags=None,
4011    ):
4012        self.appurl = appurl if appurl is not None else ''
4013        self.id = id if id is not None else ''
4014        '''
4015         Unique identifier of the SecretStore.
4016        '''
4017        self.name = name if name is not None else ''
4018        '''
4019         Unique human-readable name of the SecretStore.
4020        '''
4021        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4022        '''
4023         Tags is a map of key, value pairs.
4024        '''
4025
4026    def __repr__(self):
4027        return '<sdm.CyberarkPAMExperimentalStore ' + \
4028            'appurl: ' + repr(self.appurl) + ' ' +\
4029            'id: ' + repr(self.id) + ' ' +\
4030            'name: ' + repr(self.name) + ' ' +\
4031            'tags: ' + repr(self.tags) + ' ' +\
4032            '>'
4033
4034    def to_dict(self):
4035        return {
4036            'appurl': self.appurl,
4037            'id': self.id,
4038            'name': self.name,
4039            'tags': self.tags,
4040        }
4041
4042    @classmethod
4043    def from_dict(cls, d):
4044        return cls(
4045            appurl=d.get('appurl'),
4046            id=d.get('id'),
4047            name=d.get('name'),
4048            tags=d.get('tags'),
4049        )

CyberarkPAMExperimentalStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

CyberarkPAMExperimentalStore(appurl=None, id=None, name=None, tags=None)
4005    def __init__(
4006        self,
4007        appurl=None,
4008        id=None,
4009        name=None,
4010        tags=None,
4011    ):
4012        self.appurl = appurl if appurl is not None else ''
4013        self.id = id if id is not None else ''
4014        '''
4015         Unique identifier of the SecretStore.
4016        '''
4017        self.name = name if name is not None else ''
4018        '''
4019         Unique human-readable name of the SecretStore.
4020        '''
4021        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4022        '''
4023         Tags is a map of key, value pairs.
4024        '''
appurl
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4034    def to_dict(self):
4035        return {
4036            'appurl': self.appurl,
4037            'id': self.id,
4038            'name': self.name,
4039            'tags': self.tags,
4040        }
@classmethod
def from_dict(cls, d)
4042    @classmethod
4043    def from_dict(cls, d):
4044        return cls(
4045            appurl=d.get('appurl'),
4046            id=d.get('id'),
4047            name=d.get('name'),
4048            tags=d.get('tags'),
4049        )
class DB2I:
4052class DB2I:
4053    __slots__ = [
4054        'bind_interface',
4055        'egress_filter',
4056        'healthy',
4057        'hostname',
4058        'id',
4059        'name',
4060        'password',
4061        'port',
4062        'port_override',
4063        'secret_store_id',
4064        'tags',
4065        'tls_required',
4066        'username',
4067    ]
4068
4069    def __init__(
4070        self,
4071        bind_interface=None,
4072        egress_filter=None,
4073        healthy=None,
4074        hostname=None,
4075        id=None,
4076        name=None,
4077        password=None,
4078        port=None,
4079        port_override=None,
4080        secret_store_id=None,
4081        tags=None,
4082        tls_required=None,
4083        username=None,
4084    ):
4085        self.bind_interface = bind_interface if bind_interface is not None else ''
4086        '''
4087         Bind interface
4088        '''
4089        self.egress_filter = egress_filter if egress_filter is not None else ''
4090        '''
4091         A filter applied to the routing logic to pin datasource to nodes.
4092        '''
4093        self.healthy = healthy if healthy is not None else False
4094        '''
4095         True if the datasource is reachable and the credentials are valid.
4096        '''
4097        self.hostname = hostname if hostname is not None else ''
4098        self.id = id if id is not None else ''
4099        '''
4100         Unique identifier of the Resource.
4101        '''
4102        self.name = name if name is not None else ''
4103        '''
4104         Unique human-readable name of the Resource.
4105        '''
4106        self.password = password if password is not None else ''
4107        self.port = port if port is not None else 0
4108        self.port_override = port_override if port_override is not None else 0
4109        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4110        '''
4111         ID of the secret store containing credentials for this resource, if any.
4112        '''
4113        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4114        '''
4115         Tags is a map of key, value pairs.
4116        '''
4117        self.tls_required = tls_required if tls_required is not None else False
4118        self.username = username if username is not None else ''
4119
4120    def __repr__(self):
4121        return '<sdm.DB2I ' + \
4122            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4123            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4124            'healthy: ' + repr(self.healthy) + ' ' +\
4125            'hostname: ' + repr(self.hostname) + ' ' +\
4126            'id: ' + repr(self.id) + ' ' +\
4127            'name: ' + repr(self.name) + ' ' +\
4128            'password: ' + repr(self.password) + ' ' +\
4129            'port: ' + repr(self.port) + ' ' +\
4130            'port_override: ' + repr(self.port_override) + ' ' +\
4131            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4132            'tags: ' + repr(self.tags) + ' ' +\
4133            'tls_required: ' + repr(self.tls_required) + ' ' +\
4134            'username: ' + repr(self.username) + ' ' +\
4135            '>'
4136
4137    def to_dict(self):
4138        return {
4139            'bind_interface': self.bind_interface,
4140            'egress_filter': self.egress_filter,
4141            'healthy': self.healthy,
4142            'hostname': self.hostname,
4143            'id': self.id,
4144            'name': self.name,
4145            'password': self.password,
4146            'port': self.port,
4147            'port_override': self.port_override,
4148            'secret_store_id': self.secret_store_id,
4149            'tags': self.tags,
4150            'tls_required': self.tls_required,
4151            'username': self.username,
4152        }
4153
4154    @classmethod
4155    def from_dict(cls, d):
4156        return cls(
4157            bind_interface=d.get('bind_interface'),
4158            egress_filter=d.get('egress_filter'),
4159            healthy=d.get('healthy'),
4160            hostname=d.get('hostname'),
4161            id=d.get('id'),
4162            name=d.get('name'),
4163            password=d.get('password'),
4164            port=d.get('port'),
4165            port_override=d.get('port_override'),
4166            secret_store_id=d.get('secret_store_id'),
4167            tags=d.get('tags'),
4168            tls_required=d.get('tls_required'),
4169            username=d.get('username'),
4170        )
DB2I( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4069    def __init__(
4070        self,
4071        bind_interface=None,
4072        egress_filter=None,
4073        healthy=None,
4074        hostname=None,
4075        id=None,
4076        name=None,
4077        password=None,
4078        port=None,
4079        port_override=None,
4080        secret_store_id=None,
4081        tags=None,
4082        tls_required=None,
4083        username=None,
4084    ):
4085        self.bind_interface = bind_interface if bind_interface is not None else ''
4086        '''
4087         Bind interface
4088        '''
4089        self.egress_filter = egress_filter if egress_filter is not None else ''
4090        '''
4091         A filter applied to the routing logic to pin datasource to nodes.
4092        '''
4093        self.healthy = healthy if healthy is not None else False
4094        '''
4095         True if the datasource is reachable and the credentials are valid.
4096        '''
4097        self.hostname = hostname if hostname is not None else ''
4098        self.id = id if id is not None else ''
4099        '''
4100         Unique identifier of the Resource.
4101        '''
4102        self.name = name if name is not None else ''
4103        '''
4104         Unique human-readable name of the Resource.
4105        '''
4106        self.password = password if password is not None else ''
4107        self.port = port if port is not None else 0
4108        self.port_override = port_override if port_override is not None else 0
4109        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4110        '''
4111         ID of the secret store containing credentials for this resource, if any.
4112        '''
4113        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4114        '''
4115         Tags is a map of key, value pairs.
4116        '''
4117        self.tls_required = tls_required if tls_required is not None else False
4118        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4137    def to_dict(self):
4138        return {
4139            'bind_interface': self.bind_interface,
4140            'egress_filter': self.egress_filter,
4141            'healthy': self.healthy,
4142            'hostname': self.hostname,
4143            'id': self.id,
4144            'name': self.name,
4145            'password': self.password,
4146            'port': self.port,
4147            'port_override': self.port_override,
4148            'secret_store_id': self.secret_store_id,
4149            'tags': self.tags,
4150            'tls_required': self.tls_required,
4151            'username': self.username,
4152        }
@classmethod
def from_dict(cls, d)
4154    @classmethod
4155    def from_dict(cls, d):
4156        return cls(
4157            bind_interface=d.get('bind_interface'),
4158            egress_filter=d.get('egress_filter'),
4159            healthy=d.get('healthy'),
4160            hostname=d.get('hostname'),
4161            id=d.get('id'),
4162            name=d.get('name'),
4163            password=d.get('password'),
4164            port=d.get('port'),
4165            port_override=d.get('port_override'),
4166            secret_store_id=d.get('secret_store_id'),
4167            tags=d.get('tags'),
4168            tls_required=d.get('tls_required'),
4169            username=d.get('username'),
4170        )
class DB2LUW:
4173class DB2LUW:
4174    __slots__ = [
4175        'bind_interface',
4176        'database',
4177        'egress_filter',
4178        'healthy',
4179        'hostname',
4180        'id',
4181        'name',
4182        'password',
4183        'port',
4184        'port_override',
4185        'secret_store_id',
4186        'tags',
4187        'username',
4188    ]
4189
4190    def __init__(
4191        self,
4192        bind_interface=None,
4193        database=None,
4194        egress_filter=None,
4195        healthy=None,
4196        hostname=None,
4197        id=None,
4198        name=None,
4199        password=None,
4200        port=None,
4201        port_override=None,
4202        secret_store_id=None,
4203        tags=None,
4204        username=None,
4205    ):
4206        self.bind_interface = bind_interface if bind_interface is not None else ''
4207        '''
4208         Bind interface
4209        '''
4210        self.database = database if database is not None else ''
4211        self.egress_filter = egress_filter if egress_filter is not None else ''
4212        '''
4213         A filter applied to the routing logic to pin datasource to nodes.
4214        '''
4215        self.healthy = healthy if healthy is not None else False
4216        '''
4217         True if the datasource is reachable and the credentials are valid.
4218        '''
4219        self.hostname = hostname if hostname is not None else ''
4220        self.id = id if id is not None else ''
4221        '''
4222         Unique identifier of the Resource.
4223        '''
4224        self.name = name if name is not None else ''
4225        '''
4226         Unique human-readable name of the Resource.
4227        '''
4228        self.password = password if password is not None else ''
4229        self.port = port if port is not None else 0
4230        self.port_override = port_override if port_override is not None else 0
4231        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4232        '''
4233         ID of the secret store containing credentials for this resource, if any.
4234        '''
4235        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4236        '''
4237         Tags is a map of key, value pairs.
4238        '''
4239        self.username = username if username is not None else ''
4240
4241    def __repr__(self):
4242        return '<sdm.DB2LUW ' + \
4243            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4244            'database: ' + repr(self.database) + ' ' +\
4245            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4246            'healthy: ' + repr(self.healthy) + ' ' +\
4247            'hostname: ' + repr(self.hostname) + ' ' +\
4248            'id: ' + repr(self.id) + ' ' +\
4249            'name: ' + repr(self.name) + ' ' +\
4250            'password: ' + repr(self.password) + ' ' +\
4251            'port: ' + repr(self.port) + ' ' +\
4252            'port_override: ' + repr(self.port_override) + ' ' +\
4253            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4254            'tags: ' + repr(self.tags) + ' ' +\
4255            'username: ' + repr(self.username) + ' ' +\
4256            '>'
4257
4258    def to_dict(self):
4259        return {
4260            'bind_interface': self.bind_interface,
4261            'database': self.database,
4262            'egress_filter': self.egress_filter,
4263            'healthy': self.healthy,
4264            'hostname': self.hostname,
4265            'id': self.id,
4266            'name': self.name,
4267            'password': self.password,
4268            'port': self.port,
4269            'port_override': self.port_override,
4270            'secret_store_id': self.secret_store_id,
4271            'tags': self.tags,
4272            'username': self.username,
4273        }
4274
4275    @classmethod
4276    def from_dict(cls, d):
4277        return cls(
4278            bind_interface=d.get('bind_interface'),
4279            database=d.get('database'),
4280            egress_filter=d.get('egress_filter'),
4281            healthy=d.get('healthy'),
4282            hostname=d.get('hostname'),
4283            id=d.get('id'),
4284            name=d.get('name'),
4285            password=d.get('password'),
4286            port=d.get('port'),
4287            port_override=d.get('port_override'),
4288            secret_store_id=d.get('secret_store_id'),
4289            tags=d.get('tags'),
4290            username=d.get('username'),
4291        )
DB2LUW( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4190    def __init__(
4191        self,
4192        bind_interface=None,
4193        database=None,
4194        egress_filter=None,
4195        healthy=None,
4196        hostname=None,
4197        id=None,
4198        name=None,
4199        password=None,
4200        port=None,
4201        port_override=None,
4202        secret_store_id=None,
4203        tags=None,
4204        username=None,
4205    ):
4206        self.bind_interface = bind_interface if bind_interface is not None else ''
4207        '''
4208         Bind interface
4209        '''
4210        self.database = database if database is not None else ''
4211        self.egress_filter = egress_filter if egress_filter is not None else ''
4212        '''
4213         A filter applied to the routing logic to pin datasource to nodes.
4214        '''
4215        self.healthy = healthy if healthy is not None else False
4216        '''
4217         True if the datasource is reachable and the credentials are valid.
4218        '''
4219        self.hostname = hostname if hostname is not None else ''
4220        self.id = id if id is not None else ''
4221        '''
4222         Unique identifier of the Resource.
4223        '''
4224        self.name = name if name is not None else ''
4225        '''
4226         Unique human-readable name of the Resource.
4227        '''
4228        self.password = password if password is not None else ''
4229        self.port = port if port is not None else 0
4230        self.port_override = port_override if port_override is not None else 0
4231        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4232        '''
4233         ID of the secret store containing credentials for this resource, if any.
4234        '''
4235        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4236        '''
4237         Tags is a map of key, value pairs.
4238        '''
4239        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4258    def to_dict(self):
4259        return {
4260            'bind_interface': self.bind_interface,
4261            'database': self.database,
4262            'egress_filter': self.egress_filter,
4263            'healthy': self.healthy,
4264            'hostname': self.hostname,
4265            'id': self.id,
4266            'name': self.name,
4267            'password': self.password,
4268            'port': self.port,
4269            'port_override': self.port_override,
4270            'secret_store_id': self.secret_store_id,
4271            'tags': self.tags,
4272            'username': self.username,
4273        }
@classmethod
def from_dict(cls, d)
4275    @classmethod
4276    def from_dict(cls, d):
4277        return cls(
4278            bind_interface=d.get('bind_interface'),
4279            database=d.get('database'),
4280            egress_filter=d.get('egress_filter'),
4281            healthy=d.get('healthy'),
4282            hostname=d.get('hostname'),
4283            id=d.get('id'),
4284            name=d.get('name'),
4285            password=d.get('password'),
4286            port=d.get('port'),
4287            port_override=d.get('port_override'),
4288            secret_store_id=d.get('secret_store_id'),
4289            tags=d.get('tags'),
4290            username=d.get('username'),
4291        )
class DeleteResponseMetadata:
4294class DeleteResponseMetadata:
4295    '''
4296         DeleteResponseMetadata is reserved for future use.
4297    '''
4298    __slots__ = []
4299
4300    def __init__(self, ):
4301        pass
4302
4303    def __repr__(self):
4304        return '<sdm.DeleteResponseMetadata ' + \
4305            '>'
4306
4307    def to_dict(self):
4308        return {}
4309
4310    @classmethod
4311    def from_dict(cls, d):
4312        return cls()

DeleteResponseMetadata is reserved for future use.

DeleteResponseMetadata()
4300    def __init__(self, ):
4301        pass
def to_dict(self)
4307    def to_dict(self):
4308        return {}
@classmethod
def from_dict(cls, d)
4310    @classmethod
4311    def from_dict(cls, d):
4312        return cls()
class DelineaStore:
4315class DelineaStore:
4316    '''
4317    DelineaStore is currently unstable, and its API may change, or it may be removed,
4318    without a major version bump.
4319    '''
4320    __slots__ = [
4321        'id',
4322        'name',
4323        'server_url',
4324        'tags',
4325        'tenant_name',
4326    ]
4327
4328    def __init__(
4329        self,
4330        id=None,
4331        name=None,
4332        server_url=None,
4333        tags=None,
4334        tenant_name=None,
4335    ):
4336        self.id = id if id is not None else ''
4337        '''
4338         Unique identifier of the SecretStore.
4339        '''
4340        self.name = name if name is not None else ''
4341        '''
4342         Unique human-readable name of the SecretStore.
4343        '''
4344        self.server_url = server_url if server_url is not None else ''
4345        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4346        '''
4347         Tags is a map of key, value pairs.
4348        '''
4349        self.tenant_name = tenant_name if tenant_name is not None else ''
4350
4351    def __repr__(self):
4352        return '<sdm.DelineaStore ' + \
4353            'id: ' + repr(self.id) + ' ' +\
4354            'name: ' + repr(self.name) + ' ' +\
4355            'server_url: ' + repr(self.server_url) + ' ' +\
4356            'tags: ' + repr(self.tags) + ' ' +\
4357            'tenant_name: ' + repr(self.tenant_name) + ' ' +\
4358            '>'
4359
4360    def to_dict(self):
4361        return {
4362            'id': self.id,
4363            'name': self.name,
4364            'server_url': self.server_url,
4365            'tags': self.tags,
4366            'tenant_name': self.tenant_name,
4367        }
4368
4369    @classmethod
4370    def from_dict(cls, d):
4371        return cls(
4372            id=d.get('id'),
4373            name=d.get('name'),
4374            server_url=d.get('server_url'),
4375            tags=d.get('tags'),
4376            tenant_name=d.get('tenant_name'),
4377        )

DelineaStore is currently unstable, and its API may change, or it may be removed, without a major version bump.

DelineaStore(id=None, name=None, server_url=None, tags=None, tenant_name=None)
4328    def __init__(
4329        self,
4330        id=None,
4331        name=None,
4332        server_url=None,
4333        tags=None,
4334        tenant_name=None,
4335    ):
4336        self.id = id if id is not None else ''
4337        '''
4338         Unique identifier of the SecretStore.
4339        '''
4340        self.name = name if name is not None else ''
4341        '''
4342         Unique human-readable name of the SecretStore.
4343        '''
4344        self.server_url = server_url if server_url is not None else ''
4345        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4346        '''
4347         Tags is a map of key, value pairs.
4348        '''
4349        self.tenant_name = tenant_name if tenant_name is not None else ''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

server_url
tags

Tags is a map of key, value pairs.

tenant_name
def to_dict(self)
4360    def to_dict(self):
4361        return {
4362            'id': self.id,
4363            'name': self.name,
4364            'server_url': self.server_url,
4365            'tags': self.tags,
4366            'tenant_name': self.tenant_name,
4367        }
@classmethod
def from_dict(cls, d)
4369    @classmethod
4370    def from_dict(cls, d):
4371        return cls(
4372            id=d.get('id'),
4373            name=d.get('name'),
4374            server_url=d.get('server_url'),
4375            tags=d.get('tags'),
4376            tenant_name=d.get('tenant_name'),
4377        )
class DocumentDBHost:
4380class DocumentDBHost:
4381    __slots__ = [
4382        'auth_database',
4383        'bind_interface',
4384        'egress_filter',
4385        'healthy',
4386        'hostname',
4387        'id',
4388        'name',
4389        'password',
4390        'port',
4391        'port_override',
4392        'secret_store_id',
4393        'tags',
4394        'username',
4395    ]
4396
4397    def __init__(
4398        self,
4399        auth_database=None,
4400        bind_interface=None,
4401        egress_filter=None,
4402        healthy=None,
4403        hostname=None,
4404        id=None,
4405        name=None,
4406        password=None,
4407        port=None,
4408        port_override=None,
4409        secret_store_id=None,
4410        tags=None,
4411        username=None,
4412    ):
4413        self.auth_database = auth_database if auth_database is not None else ''
4414        self.bind_interface = bind_interface if bind_interface is not None else ''
4415        '''
4416         Bind interface
4417        '''
4418        self.egress_filter = egress_filter if egress_filter is not None else ''
4419        '''
4420         A filter applied to the routing logic to pin datasource to nodes.
4421        '''
4422        self.healthy = healthy if healthy is not None else False
4423        '''
4424         True if the datasource is reachable and the credentials are valid.
4425        '''
4426        self.hostname = hostname if hostname is not None else ''
4427        self.id = id if id is not None else ''
4428        '''
4429         Unique identifier of the Resource.
4430        '''
4431        self.name = name if name is not None else ''
4432        '''
4433         Unique human-readable name of the Resource.
4434        '''
4435        self.password = password if password is not None else ''
4436        self.port = port if port is not None else 0
4437        self.port_override = port_override if port_override is not None else 0
4438        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4439        '''
4440         ID of the secret store containing credentials for this resource, if any.
4441        '''
4442        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4443        '''
4444         Tags is a map of key, value pairs.
4445        '''
4446        self.username = username if username is not None else ''
4447
4448    def __repr__(self):
4449        return '<sdm.DocumentDBHost ' + \
4450            'auth_database: ' + repr(self.auth_database) + ' ' +\
4451            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4452            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4453            'healthy: ' + repr(self.healthy) + ' ' +\
4454            'hostname: ' + repr(self.hostname) + ' ' +\
4455            'id: ' + repr(self.id) + ' ' +\
4456            'name: ' + repr(self.name) + ' ' +\
4457            'password: ' + repr(self.password) + ' ' +\
4458            'port: ' + repr(self.port) + ' ' +\
4459            'port_override: ' + repr(self.port_override) + ' ' +\
4460            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4461            'tags: ' + repr(self.tags) + ' ' +\
4462            'username: ' + repr(self.username) + ' ' +\
4463            '>'
4464
4465    def to_dict(self):
4466        return {
4467            'auth_database': self.auth_database,
4468            'bind_interface': self.bind_interface,
4469            'egress_filter': self.egress_filter,
4470            'healthy': self.healthy,
4471            'hostname': self.hostname,
4472            'id': self.id,
4473            'name': self.name,
4474            'password': self.password,
4475            'port': self.port,
4476            'port_override': self.port_override,
4477            'secret_store_id': self.secret_store_id,
4478            'tags': self.tags,
4479            'username': self.username,
4480        }
4481
4482    @classmethod
4483    def from_dict(cls, d):
4484        return cls(
4485            auth_database=d.get('auth_database'),
4486            bind_interface=d.get('bind_interface'),
4487            egress_filter=d.get('egress_filter'),
4488            healthy=d.get('healthy'),
4489            hostname=d.get('hostname'),
4490            id=d.get('id'),
4491            name=d.get('name'),
4492            password=d.get('password'),
4493            port=d.get('port'),
4494            port_override=d.get('port_override'),
4495            secret_store_id=d.get('secret_store_id'),
4496            tags=d.get('tags'),
4497            username=d.get('username'),
4498        )
DocumentDBHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4397    def __init__(
4398        self,
4399        auth_database=None,
4400        bind_interface=None,
4401        egress_filter=None,
4402        healthy=None,
4403        hostname=None,
4404        id=None,
4405        name=None,
4406        password=None,
4407        port=None,
4408        port_override=None,
4409        secret_store_id=None,
4410        tags=None,
4411        username=None,
4412    ):
4413        self.auth_database = auth_database if auth_database is not None else ''
4414        self.bind_interface = bind_interface if bind_interface is not None else ''
4415        '''
4416         Bind interface
4417        '''
4418        self.egress_filter = egress_filter if egress_filter is not None else ''
4419        '''
4420         A filter applied to the routing logic to pin datasource to nodes.
4421        '''
4422        self.healthy = healthy if healthy is not None else False
4423        '''
4424         True if the datasource is reachable and the credentials are valid.
4425        '''
4426        self.hostname = hostname if hostname is not None else ''
4427        self.id = id if id is not None else ''
4428        '''
4429         Unique identifier of the Resource.
4430        '''
4431        self.name = name if name is not None else ''
4432        '''
4433         Unique human-readable name of the Resource.
4434        '''
4435        self.password = password if password is not None else ''
4436        self.port = port if port is not None else 0
4437        self.port_override = port_override if port_override is not None else 0
4438        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4439        '''
4440         ID of the secret store containing credentials for this resource, if any.
4441        '''
4442        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4443        '''
4444         Tags is a map of key, value pairs.
4445        '''
4446        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4465    def to_dict(self):
4466        return {
4467            'auth_database': self.auth_database,
4468            'bind_interface': self.bind_interface,
4469            'egress_filter': self.egress_filter,
4470            'healthy': self.healthy,
4471            'hostname': self.hostname,
4472            'id': self.id,
4473            'name': self.name,
4474            'password': self.password,
4475            'port': self.port,
4476            'port_override': self.port_override,
4477            'secret_store_id': self.secret_store_id,
4478            'tags': self.tags,
4479            'username': self.username,
4480        }
@classmethod
def from_dict(cls, d)
4482    @classmethod
4483    def from_dict(cls, d):
4484        return cls(
4485            auth_database=d.get('auth_database'),
4486            bind_interface=d.get('bind_interface'),
4487            egress_filter=d.get('egress_filter'),
4488            healthy=d.get('healthy'),
4489            hostname=d.get('hostname'),
4490            id=d.get('id'),
4491            name=d.get('name'),
4492            password=d.get('password'),
4493            port=d.get('port'),
4494            port_override=d.get('port_override'),
4495            secret_store_id=d.get('secret_store_id'),
4496            tags=d.get('tags'),
4497            username=d.get('username'),
4498        )
class DocumentDBReplicaSet:
4501class DocumentDBReplicaSet:
4502    __slots__ = [
4503        'auth_database',
4504        'bind_interface',
4505        'connect_to_replica',
4506        'egress_filter',
4507        'healthy',
4508        'hostname',
4509        'id',
4510        'name',
4511        'password',
4512        'port_override',
4513        'replica_set',
4514        'secret_store_id',
4515        'tags',
4516        'username',
4517    ]
4518
4519    def __init__(
4520        self,
4521        auth_database=None,
4522        bind_interface=None,
4523        connect_to_replica=None,
4524        egress_filter=None,
4525        healthy=None,
4526        hostname=None,
4527        id=None,
4528        name=None,
4529        password=None,
4530        port_override=None,
4531        replica_set=None,
4532        secret_store_id=None,
4533        tags=None,
4534        username=None,
4535    ):
4536        self.auth_database = auth_database if auth_database is not None else ''
4537        self.bind_interface = bind_interface if bind_interface is not None else ''
4538        '''
4539         Bind interface
4540        '''
4541        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4542        self.egress_filter = egress_filter if egress_filter is not None else ''
4543        '''
4544         A filter applied to the routing logic to pin datasource to nodes.
4545        '''
4546        self.healthy = healthy if healthy is not None else False
4547        '''
4548         True if the datasource is reachable and the credentials are valid.
4549        '''
4550        self.hostname = hostname if hostname is not None else ''
4551        '''
4552         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4553        '''
4554        self.id = id if id is not None else ''
4555        '''
4556         Unique identifier of the Resource.
4557        '''
4558        self.name = name if name is not None else ''
4559        '''
4560         Unique human-readable name of the Resource.
4561        '''
4562        self.password = password if password is not None else ''
4563        self.port_override = port_override if port_override is not None else 0
4564        self.replica_set = replica_set if replica_set is not None else ''
4565        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4566        '''
4567         ID of the secret store containing credentials for this resource, if any.
4568        '''
4569        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4570        '''
4571         Tags is a map of key, value pairs.
4572        '''
4573        self.username = username if username is not None else ''
4574
4575    def __repr__(self):
4576        return '<sdm.DocumentDBReplicaSet ' + \
4577            'auth_database: ' + repr(self.auth_database) + ' ' +\
4578            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4579            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
4580            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4581            'healthy: ' + repr(self.healthy) + ' ' +\
4582            'hostname: ' + repr(self.hostname) + ' ' +\
4583            'id: ' + repr(self.id) + ' ' +\
4584            'name: ' + repr(self.name) + ' ' +\
4585            'password: ' + repr(self.password) + ' ' +\
4586            'port_override: ' + repr(self.port_override) + ' ' +\
4587            'replica_set: ' + repr(self.replica_set) + ' ' +\
4588            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4589            'tags: ' + repr(self.tags) + ' ' +\
4590            'username: ' + repr(self.username) + ' ' +\
4591            '>'
4592
4593    def to_dict(self):
4594        return {
4595            'auth_database': self.auth_database,
4596            'bind_interface': self.bind_interface,
4597            'connect_to_replica': self.connect_to_replica,
4598            'egress_filter': self.egress_filter,
4599            'healthy': self.healthy,
4600            'hostname': self.hostname,
4601            'id': self.id,
4602            'name': self.name,
4603            'password': self.password,
4604            'port_override': self.port_override,
4605            'replica_set': self.replica_set,
4606            'secret_store_id': self.secret_store_id,
4607            'tags': self.tags,
4608            'username': self.username,
4609        }
4610
4611    @classmethod
4612    def from_dict(cls, d):
4613        return cls(
4614            auth_database=d.get('auth_database'),
4615            bind_interface=d.get('bind_interface'),
4616            connect_to_replica=d.get('connect_to_replica'),
4617            egress_filter=d.get('egress_filter'),
4618            healthy=d.get('healthy'),
4619            hostname=d.get('hostname'),
4620            id=d.get('id'),
4621            name=d.get('name'),
4622            password=d.get('password'),
4623            port_override=d.get('port_override'),
4624            replica_set=d.get('replica_set'),
4625            secret_store_id=d.get('secret_store_id'),
4626            tags=d.get('tags'),
4627            username=d.get('username'),
4628        )
DocumentDBReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None)
4519    def __init__(
4520        self,
4521        auth_database=None,
4522        bind_interface=None,
4523        connect_to_replica=None,
4524        egress_filter=None,
4525        healthy=None,
4526        hostname=None,
4527        id=None,
4528        name=None,
4529        password=None,
4530        port_override=None,
4531        replica_set=None,
4532        secret_store_id=None,
4533        tags=None,
4534        username=None,
4535    ):
4536        self.auth_database = auth_database if auth_database is not None else ''
4537        self.bind_interface = bind_interface if bind_interface is not None else ''
4538        '''
4539         Bind interface
4540        '''
4541        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4542        self.egress_filter = egress_filter if egress_filter is not None else ''
4543        '''
4544         A filter applied to the routing logic to pin datasource to nodes.
4545        '''
4546        self.healthy = healthy if healthy is not None else False
4547        '''
4548         True if the datasource is reachable and the credentials are valid.
4549        '''
4550        self.hostname = hostname if hostname is not None else ''
4551        '''
4552         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4553        '''
4554        self.id = id if id is not None else ''
4555        '''
4556         Unique identifier of the Resource.
4557        '''
4558        self.name = name if name is not None else ''
4559        '''
4560         Unique human-readable name of the Resource.
4561        '''
4562        self.password = password if password is not None else ''
4563        self.port_override = port_override if port_override is not None else 0
4564        self.replica_set = replica_set if replica_set is not None else ''
4565        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4566        '''
4567         ID of the secret store containing credentials for this resource, if any.
4568        '''
4569        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4570        '''
4571         Tags is a map of key, value pairs.
4572        '''
4573        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname

Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4593    def to_dict(self):
4594        return {
4595            'auth_database': self.auth_database,
4596            'bind_interface': self.bind_interface,
4597            'connect_to_replica': self.connect_to_replica,
4598            'egress_filter': self.egress_filter,
4599            'healthy': self.healthy,
4600            'hostname': self.hostname,
4601            'id': self.id,
4602            'name': self.name,
4603            'password': self.password,
4604            'port_override': self.port_override,
4605            'replica_set': self.replica_set,
4606            'secret_store_id': self.secret_store_id,
4607            'tags': self.tags,
4608            'username': self.username,
4609        }
@classmethod
def from_dict(cls, d)
4611    @classmethod
4612    def from_dict(cls, d):
4613        return cls(
4614            auth_database=d.get('auth_database'),
4615            bind_interface=d.get('bind_interface'),
4616            connect_to_replica=d.get('connect_to_replica'),
4617            egress_filter=d.get('egress_filter'),
4618            healthy=d.get('healthy'),
4619            hostname=d.get('hostname'),
4620            id=d.get('id'),
4621            name=d.get('name'),
4622            password=d.get('password'),
4623            port_override=d.get('port_override'),
4624            replica_set=d.get('replica_set'),
4625            secret_store_id=d.get('secret_store_id'),
4626            tags=d.get('tags'),
4627            username=d.get('username'),
4628        )
class Druid:
4631class Druid:
4632    __slots__ = [
4633        'bind_interface',
4634        'egress_filter',
4635        'healthy',
4636        'hostname',
4637        'id',
4638        'name',
4639        'password',
4640        'port',
4641        'port_override',
4642        'secret_store_id',
4643        'tags',
4644        'username',
4645    ]
4646
4647    def __init__(
4648        self,
4649        bind_interface=None,
4650        egress_filter=None,
4651        healthy=None,
4652        hostname=None,
4653        id=None,
4654        name=None,
4655        password=None,
4656        port=None,
4657        port_override=None,
4658        secret_store_id=None,
4659        tags=None,
4660        username=None,
4661    ):
4662        self.bind_interface = bind_interface if bind_interface is not None else ''
4663        '''
4664         Bind interface
4665        '''
4666        self.egress_filter = egress_filter if egress_filter is not None else ''
4667        '''
4668         A filter applied to the routing logic to pin datasource to nodes.
4669        '''
4670        self.healthy = healthy if healthy is not None else False
4671        '''
4672         True if the datasource is reachable and the credentials are valid.
4673        '''
4674        self.hostname = hostname if hostname is not None else ''
4675        self.id = id if id is not None else ''
4676        '''
4677         Unique identifier of the Resource.
4678        '''
4679        self.name = name if name is not None else ''
4680        '''
4681         Unique human-readable name of the Resource.
4682        '''
4683        self.password = password if password is not None else ''
4684        self.port = port if port is not None else 0
4685        self.port_override = port_override if port_override is not None else 0
4686        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4687        '''
4688         ID of the secret store containing credentials for this resource, if any.
4689        '''
4690        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4691        '''
4692         Tags is a map of key, value pairs.
4693        '''
4694        self.username = username if username is not None else ''
4695
4696    def __repr__(self):
4697        return '<sdm.Druid ' + \
4698            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4699            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4700            'healthy: ' + repr(self.healthy) + ' ' +\
4701            'hostname: ' + repr(self.hostname) + ' ' +\
4702            'id: ' + repr(self.id) + ' ' +\
4703            'name: ' + repr(self.name) + ' ' +\
4704            'password: ' + repr(self.password) + ' ' +\
4705            'port: ' + repr(self.port) + ' ' +\
4706            'port_override: ' + repr(self.port_override) + ' ' +\
4707            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4708            'tags: ' + repr(self.tags) + ' ' +\
4709            'username: ' + repr(self.username) + ' ' +\
4710            '>'
4711
4712    def to_dict(self):
4713        return {
4714            'bind_interface': self.bind_interface,
4715            'egress_filter': self.egress_filter,
4716            'healthy': self.healthy,
4717            'hostname': self.hostname,
4718            'id': self.id,
4719            'name': self.name,
4720            'password': self.password,
4721            'port': self.port,
4722            'port_override': self.port_override,
4723            'secret_store_id': self.secret_store_id,
4724            'tags': self.tags,
4725            'username': self.username,
4726        }
4727
4728    @classmethod
4729    def from_dict(cls, d):
4730        return cls(
4731            bind_interface=d.get('bind_interface'),
4732            egress_filter=d.get('egress_filter'),
4733            healthy=d.get('healthy'),
4734            hostname=d.get('hostname'),
4735            id=d.get('id'),
4736            name=d.get('name'),
4737            password=d.get('password'),
4738            port=d.get('port'),
4739            port_override=d.get('port_override'),
4740            secret_store_id=d.get('secret_store_id'),
4741            tags=d.get('tags'),
4742            username=d.get('username'),
4743        )
Druid( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4647    def __init__(
4648        self,
4649        bind_interface=None,
4650        egress_filter=None,
4651        healthy=None,
4652        hostname=None,
4653        id=None,
4654        name=None,
4655        password=None,
4656        port=None,
4657        port_override=None,
4658        secret_store_id=None,
4659        tags=None,
4660        username=None,
4661    ):
4662        self.bind_interface = bind_interface if bind_interface is not None else ''
4663        '''
4664         Bind interface
4665        '''
4666        self.egress_filter = egress_filter if egress_filter is not None else ''
4667        '''
4668         A filter applied to the routing logic to pin datasource to nodes.
4669        '''
4670        self.healthy = healthy if healthy is not None else False
4671        '''
4672         True if the datasource is reachable and the credentials are valid.
4673        '''
4674        self.hostname = hostname if hostname is not None else ''
4675        self.id = id if id is not None else ''
4676        '''
4677         Unique identifier of the Resource.
4678        '''
4679        self.name = name if name is not None else ''
4680        '''
4681         Unique human-readable name of the Resource.
4682        '''
4683        self.password = password if password is not None else ''
4684        self.port = port if port is not None else 0
4685        self.port_override = port_override if port_override is not None else 0
4686        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4687        '''
4688         ID of the secret store containing credentials for this resource, if any.
4689        '''
4690        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4691        '''
4692         Tags is a map of key, value pairs.
4693        '''
4694        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4712    def to_dict(self):
4713        return {
4714            'bind_interface': self.bind_interface,
4715            'egress_filter': self.egress_filter,
4716            'healthy': self.healthy,
4717            'hostname': self.hostname,
4718            'id': self.id,
4719            'name': self.name,
4720            'password': self.password,
4721            'port': self.port,
4722            'port_override': self.port_override,
4723            'secret_store_id': self.secret_store_id,
4724            'tags': self.tags,
4725            'username': self.username,
4726        }
@classmethod
def from_dict(cls, d)
4728    @classmethod
4729    def from_dict(cls, d):
4730        return cls(
4731            bind_interface=d.get('bind_interface'),
4732            egress_filter=d.get('egress_filter'),
4733            healthy=d.get('healthy'),
4734            hostname=d.get('hostname'),
4735            id=d.get('id'),
4736            name=d.get('name'),
4737            password=d.get('password'),
4738            port=d.get('port'),
4739            port_override=d.get('port_override'),
4740            secret_store_id=d.get('secret_store_id'),
4741            tags=d.get('tags'),
4742            username=d.get('username'),
4743        )
class DynamoDB:
4746class DynamoDB:
4747    __slots__ = [
4748        'access_key',
4749        'bind_interface',
4750        'egress_filter',
4751        'endpoint',
4752        'healthy',
4753        'id',
4754        'name',
4755        'port_override',
4756        'region',
4757        'role_arn',
4758        'role_external_id',
4759        'secret_access_key',
4760        'secret_store_id',
4761        'tags',
4762    ]
4763
4764    def __init__(
4765        self,
4766        access_key=None,
4767        bind_interface=None,
4768        egress_filter=None,
4769        endpoint=None,
4770        healthy=None,
4771        id=None,
4772        name=None,
4773        port_override=None,
4774        region=None,
4775        role_arn=None,
4776        role_external_id=None,
4777        secret_access_key=None,
4778        secret_store_id=None,
4779        tags=None,
4780    ):
4781        self.access_key = access_key if access_key is not None else ''
4782        self.bind_interface = bind_interface if bind_interface is not None else ''
4783        '''
4784         Bind interface
4785        '''
4786        self.egress_filter = egress_filter if egress_filter is not None else ''
4787        '''
4788         A filter applied to the routing logic to pin datasource to nodes.
4789        '''
4790        self.endpoint = endpoint if endpoint is not None else ''
4791        self.healthy = healthy if healthy is not None else False
4792        '''
4793         True if the datasource is reachable and the credentials are valid.
4794        '''
4795        self.id = id if id is not None else ''
4796        '''
4797         Unique identifier of the Resource.
4798        '''
4799        self.name = name if name is not None else ''
4800        '''
4801         Unique human-readable name of the Resource.
4802        '''
4803        self.port_override = port_override if port_override is not None else 0
4804        self.region = region if region is not None else ''
4805        self.role_arn = role_arn if role_arn is not None else ''
4806        self.role_external_id = role_external_id if role_external_id is not None else ''
4807        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4808        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4809        '''
4810         ID of the secret store containing credentials for this resource, if any.
4811        '''
4812        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4813        '''
4814         Tags is a map of key, value pairs.
4815        '''
4816
4817    def __repr__(self):
4818        return '<sdm.DynamoDB ' + \
4819            'access_key: ' + repr(self.access_key) + ' ' +\
4820            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4821            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4822            'endpoint: ' + repr(self.endpoint) + ' ' +\
4823            'healthy: ' + repr(self.healthy) + ' ' +\
4824            'id: ' + repr(self.id) + ' ' +\
4825            'name: ' + repr(self.name) + ' ' +\
4826            'port_override: ' + repr(self.port_override) + ' ' +\
4827            'region: ' + repr(self.region) + ' ' +\
4828            'role_arn: ' + repr(self.role_arn) + ' ' +\
4829            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
4830            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
4831            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4832            'tags: ' + repr(self.tags) + ' ' +\
4833            '>'
4834
4835    def to_dict(self):
4836        return {
4837            'access_key': self.access_key,
4838            'bind_interface': self.bind_interface,
4839            'egress_filter': self.egress_filter,
4840            'endpoint': self.endpoint,
4841            'healthy': self.healthy,
4842            'id': self.id,
4843            'name': self.name,
4844            'port_override': self.port_override,
4845            'region': self.region,
4846            'role_arn': self.role_arn,
4847            'role_external_id': self.role_external_id,
4848            'secret_access_key': self.secret_access_key,
4849            'secret_store_id': self.secret_store_id,
4850            'tags': self.tags,
4851        }
4852
4853    @classmethod
4854    def from_dict(cls, d):
4855        return cls(
4856            access_key=d.get('access_key'),
4857            bind_interface=d.get('bind_interface'),
4858            egress_filter=d.get('egress_filter'),
4859            endpoint=d.get('endpoint'),
4860            healthy=d.get('healthy'),
4861            id=d.get('id'),
4862            name=d.get('name'),
4863            port_override=d.get('port_override'),
4864            region=d.get('region'),
4865            role_arn=d.get('role_arn'),
4866            role_external_id=d.get('role_external_id'),
4867            secret_access_key=d.get('secret_access_key'),
4868            secret_store_id=d.get('secret_store_id'),
4869            tags=d.get('tags'),
4870        )
DynamoDB( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
4764    def __init__(
4765        self,
4766        access_key=None,
4767        bind_interface=None,
4768        egress_filter=None,
4769        endpoint=None,
4770        healthy=None,
4771        id=None,
4772        name=None,
4773        port_override=None,
4774        region=None,
4775        role_arn=None,
4776        role_external_id=None,
4777        secret_access_key=None,
4778        secret_store_id=None,
4779        tags=None,
4780    ):
4781        self.access_key = access_key if access_key is not None else ''
4782        self.bind_interface = bind_interface if bind_interface is not None else ''
4783        '''
4784         Bind interface
4785        '''
4786        self.egress_filter = egress_filter if egress_filter is not None else ''
4787        '''
4788         A filter applied to the routing logic to pin datasource to nodes.
4789        '''
4790        self.endpoint = endpoint if endpoint is not None else ''
4791        self.healthy = healthy if healthy is not None else False
4792        '''
4793         True if the datasource is reachable and the credentials are valid.
4794        '''
4795        self.id = id if id is not None else ''
4796        '''
4797         Unique identifier of the Resource.
4798        '''
4799        self.name = name if name is not None else ''
4800        '''
4801         Unique human-readable name of the Resource.
4802        '''
4803        self.port_override = port_override if port_override is not None else 0
4804        self.region = region if region is not None else ''
4805        self.role_arn = role_arn if role_arn is not None else ''
4806        self.role_external_id = role_external_id if role_external_id is not None else ''
4807        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4808        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4809        '''
4810         ID of the secret store containing credentials for this resource, if any.
4811        '''
4812        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4813        '''
4814         Tags is a map of key, value pairs.
4815        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4835    def to_dict(self):
4836        return {
4837            'access_key': self.access_key,
4838            'bind_interface': self.bind_interface,
4839            'egress_filter': self.egress_filter,
4840            'endpoint': self.endpoint,
4841            'healthy': self.healthy,
4842            'id': self.id,
4843            'name': self.name,
4844            'port_override': self.port_override,
4845            'region': self.region,
4846            'role_arn': self.role_arn,
4847            'role_external_id': self.role_external_id,
4848            'secret_access_key': self.secret_access_key,
4849            'secret_store_id': self.secret_store_id,
4850            'tags': self.tags,
4851        }
@classmethod
def from_dict(cls, d)
4853    @classmethod
4854    def from_dict(cls, d):
4855        return cls(
4856            access_key=d.get('access_key'),
4857            bind_interface=d.get('bind_interface'),
4858            egress_filter=d.get('egress_filter'),
4859            endpoint=d.get('endpoint'),
4860            healthy=d.get('healthy'),
4861            id=d.get('id'),
4862            name=d.get('name'),
4863            port_override=d.get('port_override'),
4864            region=d.get('region'),
4865            role_arn=d.get('role_arn'),
4866            role_external_id=d.get('role_external_id'),
4867            secret_access_key=d.get('secret_access_key'),
4868            secret_store_id=d.get('secret_store_id'),
4869            tags=d.get('tags'),
4870        )
class Elastic:
4873class Elastic:
4874    __slots__ = [
4875        'bind_interface',
4876        'egress_filter',
4877        'healthy',
4878        'hostname',
4879        'id',
4880        'name',
4881        'password',
4882        'port',
4883        'port_override',
4884        'secret_store_id',
4885        'tags',
4886        'tls_required',
4887        'username',
4888    ]
4889
4890    def __init__(
4891        self,
4892        bind_interface=None,
4893        egress_filter=None,
4894        healthy=None,
4895        hostname=None,
4896        id=None,
4897        name=None,
4898        password=None,
4899        port=None,
4900        port_override=None,
4901        secret_store_id=None,
4902        tags=None,
4903        tls_required=None,
4904        username=None,
4905    ):
4906        self.bind_interface = bind_interface if bind_interface is not None else ''
4907        '''
4908         Bind interface
4909        '''
4910        self.egress_filter = egress_filter if egress_filter is not None else ''
4911        '''
4912         A filter applied to the routing logic to pin datasource to nodes.
4913        '''
4914        self.healthy = healthy if healthy is not None else False
4915        '''
4916         True if the datasource is reachable and the credentials are valid.
4917        '''
4918        self.hostname = hostname if hostname is not None else ''
4919        self.id = id if id is not None else ''
4920        '''
4921         Unique identifier of the Resource.
4922        '''
4923        self.name = name if name is not None else ''
4924        '''
4925         Unique human-readable name of the Resource.
4926        '''
4927        self.password = password if password is not None else ''
4928        self.port = port if port is not None else 0
4929        self.port_override = port_override if port_override is not None else 0
4930        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4931        '''
4932         ID of the secret store containing credentials for this resource, if any.
4933        '''
4934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4935        '''
4936         Tags is a map of key, value pairs.
4937        '''
4938        self.tls_required = tls_required if tls_required is not None else False
4939        self.username = username if username is not None else ''
4940
4941    def __repr__(self):
4942        return '<sdm.Elastic ' + \
4943            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4944            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4945            'healthy: ' + repr(self.healthy) + ' ' +\
4946            'hostname: ' + repr(self.hostname) + ' ' +\
4947            'id: ' + repr(self.id) + ' ' +\
4948            'name: ' + repr(self.name) + ' ' +\
4949            'password: ' + repr(self.password) + ' ' +\
4950            'port: ' + repr(self.port) + ' ' +\
4951            'port_override: ' + repr(self.port_override) + ' ' +\
4952            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4953            'tags: ' + repr(self.tags) + ' ' +\
4954            'tls_required: ' + repr(self.tls_required) + ' ' +\
4955            'username: ' + repr(self.username) + ' ' +\
4956            '>'
4957
4958    def to_dict(self):
4959        return {
4960            'bind_interface': self.bind_interface,
4961            'egress_filter': self.egress_filter,
4962            'healthy': self.healthy,
4963            'hostname': self.hostname,
4964            'id': self.id,
4965            'name': self.name,
4966            'password': self.password,
4967            'port': self.port,
4968            'port_override': self.port_override,
4969            'secret_store_id': self.secret_store_id,
4970            'tags': self.tags,
4971            'tls_required': self.tls_required,
4972            'username': self.username,
4973        }
4974
4975    @classmethod
4976    def from_dict(cls, d):
4977        return cls(
4978            bind_interface=d.get('bind_interface'),
4979            egress_filter=d.get('egress_filter'),
4980            healthy=d.get('healthy'),
4981            hostname=d.get('hostname'),
4982            id=d.get('id'),
4983            name=d.get('name'),
4984            password=d.get('password'),
4985            port=d.get('port'),
4986            port_override=d.get('port_override'),
4987            secret_store_id=d.get('secret_store_id'),
4988            tags=d.get('tags'),
4989            tls_required=d.get('tls_required'),
4990            username=d.get('username'),
4991        )
Elastic( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4890    def __init__(
4891        self,
4892        bind_interface=None,
4893        egress_filter=None,
4894        healthy=None,
4895        hostname=None,
4896        id=None,
4897        name=None,
4898        password=None,
4899        port=None,
4900        port_override=None,
4901        secret_store_id=None,
4902        tags=None,
4903        tls_required=None,
4904        username=None,
4905    ):
4906        self.bind_interface = bind_interface if bind_interface is not None else ''
4907        '''
4908         Bind interface
4909        '''
4910        self.egress_filter = egress_filter if egress_filter is not None else ''
4911        '''
4912         A filter applied to the routing logic to pin datasource to nodes.
4913        '''
4914        self.healthy = healthy if healthy is not None else False
4915        '''
4916         True if the datasource is reachable and the credentials are valid.
4917        '''
4918        self.hostname = hostname if hostname is not None else ''
4919        self.id = id if id is not None else ''
4920        '''
4921         Unique identifier of the Resource.
4922        '''
4923        self.name = name if name is not None else ''
4924        '''
4925         Unique human-readable name of the Resource.
4926        '''
4927        self.password = password if password is not None else ''
4928        self.port = port if port is not None else 0
4929        self.port_override = port_override if port_override is not None else 0
4930        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4931        '''
4932         ID of the secret store containing credentials for this resource, if any.
4933        '''
4934        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4935        '''
4936         Tags is a map of key, value pairs.
4937        '''
4938        self.tls_required = tls_required if tls_required is not None else False
4939        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4958    def to_dict(self):
4959        return {
4960            'bind_interface': self.bind_interface,
4961            'egress_filter': self.egress_filter,
4962            'healthy': self.healthy,
4963            'hostname': self.hostname,
4964            'id': self.id,
4965            'name': self.name,
4966            'password': self.password,
4967            'port': self.port,
4968            'port_override': self.port_override,
4969            'secret_store_id': self.secret_store_id,
4970            'tags': self.tags,
4971            'tls_required': self.tls_required,
4972            'username': self.username,
4973        }
@classmethod
def from_dict(cls, d)
4975    @classmethod
4976    def from_dict(cls, d):
4977        return cls(
4978            bind_interface=d.get('bind_interface'),
4979            egress_filter=d.get('egress_filter'),
4980            healthy=d.get('healthy'),
4981            hostname=d.get('hostname'),
4982            id=d.get('id'),
4983            name=d.get('name'),
4984            password=d.get('password'),
4985            port=d.get('port'),
4986            port_override=d.get('port_override'),
4987            secret_store_id=d.get('secret_store_id'),
4988            tags=d.get('tags'),
4989            tls_required=d.get('tls_required'),
4990            username=d.get('username'),
4991        )
class ElasticacheRedis:
4994class ElasticacheRedis:
4995    __slots__ = [
4996        'bind_interface',
4997        'egress_filter',
4998        'healthy',
4999        'hostname',
5000        'id',
5001        'name',
5002        'password',
5003        'port',
5004        'port_override',
5005        'secret_store_id',
5006        'tags',
5007        'tls_required',
5008    ]
5009
5010    def __init__(
5011        self,
5012        bind_interface=None,
5013        egress_filter=None,
5014        healthy=None,
5015        hostname=None,
5016        id=None,
5017        name=None,
5018        password=None,
5019        port=None,
5020        port_override=None,
5021        secret_store_id=None,
5022        tags=None,
5023        tls_required=None,
5024    ):
5025        self.bind_interface = bind_interface if bind_interface is not None else ''
5026        '''
5027         Bind interface
5028        '''
5029        self.egress_filter = egress_filter if egress_filter is not None else ''
5030        '''
5031         A filter applied to the routing logic to pin datasource to nodes.
5032        '''
5033        self.healthy = healthy if healthy is not None else False
5034        '''
5035         True if the datasource is reachable and the credentials are valid.
5036        '''
5037        self.hostname = hostname if hostname is not None else ''
5038        self.id = id if id is not None else ''
5039        '''
5040         Unique identifier of the Resource.
5041        '''
5042        self.name = name if name is not None else ''
5043        '''
5044         Unique human-readable name of the Resource.
5045        '''
5046        self.password = password if password is not None else ''
5047        self.port = port if port is not None else 0
5048        self.port_override = port_override if port_override is not None else 0
5049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5050        '''
5051         ID of the secret store containing credentials for this resource, if any.
5052        '''
5053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5054        '''
5055         Tags is a map of key, value pairs.
5056        '''
5057        self.tls_required = tls_required if tls_required is not None else False
5058
5059    def __repr__(self):
5060        return '<sdm.ElasticacheRedis ' + \
5061            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5062            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5063            'healthy: ' + repr(self.healthy) + ' ' +\
5064            'hostname: ' + repr(self.hostname) + ' ' +\
5065            'id: ' + repr(self.id) + ' ' +\
5066            'name: ' + repr(self.name) + ' ' +\
5067            'password: ' + repr(self.password) + ' ' +\
5068            'port: ' + repr(self.port) + ' ' +\
5069            'port_override: ' + repr(self.port_override) + ' ' +\
5070            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5071            'tags: ' + repr(self.tags) + ' ' +\
5072            'tls_required: ' + repr(self.tls_required) + ' ' +\
5073            '>'
5074
5075    def to_dict(self):
5076        return {
5077            'bind_interface': self.bind_interface,
5078            'egress_filter': self.egress_filter,
5079            'healthy': self.healthy,
5080            'hostname': self.hostname,
5081            'id': self.id,
5082            'name': self.name,
5083            'password': self.password,
5084            'port': self.port,
5085            'port_override': self.port_override,
5086            'secret_store_id': self.secret_store_id,
5087            'tags': self.tags,
5088            'tls_required': self.tls_required,
5089        }
5090
5091    @classmethod
5092    def from_dict(cls, d):
5093        return cls(
5094            bind_interface=d.get('bind_interface'),
5095            egress_filter=d.get('egress_filter'),
5096            healthy=d.get('healthy'),
5097            hostname=d.get('hostname'),
5098            id=d.get('id'),
5099            name=d.get('name'),
5100            password=d.get('password'),
5101            port=d.get('port'),
5102            port_override=d.get('port_override'),
5103            secret_store_id=d.get('secret_store_id'),
5104            tags=d.get('tags'),
5105            tls_required=d.get('tls_required'),
5106        )
ElasticacheRedis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None)
5010    def __init__(
5011        self,
5012        bind_interface=None,
5013        egress_filter=None,
5014        healthy=None,
5015        hostname=None,
5016        id=None,
5017        name=None,
5018        password=None,
5019        port=None,
5020        port_override=None,
5021        secret_store_id=None,
5022        tags=None,
5023        tls_required=None,
5024    ):
5025        self.bind_interface = bind_interface if bind_interface is not None else ''
5026        '''
5027         Bind interface
5028        '''
5029        self.egress_filter = egress_filter if egress_filter is not None else ''
5030        '''
5031         A filter applied to the routing logic to pin datasource to nodes.
5032        '''
5033        self.healthy = healthy if healthy is not None else False
5034        '''
5035         True if the datasource is reachable and the credentials are valid.
5036        '''
5037        self.hostname = hostname if hostname is not None else ''
5038        self.id = id if id is not None else ''
5039        '''
5040         Unique identifier of the Resource.
5041        '''
5042        self.name = name if name is not None else ''
5043        '''
5044         Unique human-readable name of the Resource.
5045        '''
5046        self.password = password if password is not None else ''
5047        self.port = port if port is not None else 0
5048        self.port_override = port_override if port_override is not None else 0
5049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5050        '''
5051         ID of the secret store containing credentials for this resource, if any.
5052        '''
5053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5054        '''
5055         Tags is a map of key, value pairs.
5056        '''
5057        self.tls_required = tls_required if tls_required is not None else False
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
def to_dict(self)
5075    def to_dict(self):
5076        return {
5077            'bind_interface': self.bind_interface,
5078            'egress_filter': self.egress_filter,
5079            'healthy': self.healthy,
5080            'hostname': self.hostname,
5081            'id': self.id,
5082            'name': self.name,
5083            'password': self.password,
5084            'port': self.port,
5085            'port_override': self.port_override,
5086            'secret_store_id': self.secret_store_id,
5087            'tags': self.tags,
5088            'tls_required': self.tls_required,
5089        }
@classmethod
def from_dict(cls, d)
5091    @classmethod
5092    def from_dict(cls, d):
5093        return cls(
5094            bind_interface=d.get('bind_interface'),
5095            egress_filter=d.get('egress_filter'),
5096            healthy=d.get('healthy'),
5097            hostname=d.get('hostname'),
5098            id=d.get('id'),
5099            name=d.get('name'),
5100            password=d.get('password'),
5101            port=d.get('port'),
5102            port_override=d.get('port_override'),
5103            secret_store_id=d.get('secret_store_id'),
5104            tags=d.get('tags'),
5105            tls_required=d.get('tls_required'),
5106        )
class GCP:
5109class GCP:
5110    __slots__ = [
5111        'bind_interface',
5112        'egress_filter',
5113        'healthy',
5114        'id',
5115        'keyfile',
5116        'name',
5117        'scopes',
5118        'secret_store_id',
5119        'tags',
5120    ]
5121
5122    def __init__(
5123        self,
5124        bind_interface=None,
5125        egress_filter=None,
5126        healthy=None,
5127        id=None,
5128        keyfile=None,
5129        name=None,
5130        scopes=None,
5131        secret_store_id=None,
5132        tags=None,
5133    ):
5134        self.bind_interface = bind_interface if bind_interface is not None else ''
5135        '''
5136         Bind interface
5137        '''
5138        self.egress_filter = egress_filter if egress_filter is not None else ''
5139        '''
5140         A filter applied to the routing logic to pin datasource to nodes.
5141        '''
5142        self.healthy = healthy if healthy is not None else False
5143        '''
5144         True if the datasource is reachable and the credentials are valid.
5145        '''
5146        self.id = id if id is not None else ''
5147        '''
5148         Unique identifier of the Resource.
5149        '''
5150        self.keyfile = keyfile if keyfile is not None else ''
5151        self.name = name if name is not None else ''
5152        '''
5153         Unique human-readable name of the Resource.
5154        '''
5155        self.scopes = scopes if scopes is not None else ''
5156        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5157        '''
5158         ID of the secret store containing credentials for this resource, if any.
5159        '''
5160        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5161        '''
5162         Tags is a map of key, value pairs.
5163        '''
5164
5165    def __repr__(self):
5166        return '<sdm.GCP ' + \
5167            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5168            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5169            'healthy: ' + repr(self.healthy) + ' ' +\
5170            'id: ' + repr(self.id) + ' ' +\
5171            'keyfile: ' + repr(self.keyfile) + ' ' +\
5172            'name: ' + repr(self.name) + ' ' +\
5173            'scopes: ' + repr(self.scopes) + ' ' +\
5174            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5175            'tags: ' + repr(self.tags) + ' ' +\
5176            '>'
5177
5178    def to_dict(self):
5179        return {
5180            'bind_interface': self.bind_interface,
5181            'egress_filter': self.egress_filter,
5182            'healthy': self.healthy,
5183            'id': self.id,
5184            'keyfile': self.keyfile,
5185            'name': self.name,
5186            'scopes': self.scopes,
5187            'secret_store_id': self.secret_store_id,
5188            'tags': self.tags,
5189        }
5190
5191    @classmethod
5192    def from_dict(cls, d):
5193        return cls(
5194            bind_interface=d.get('bind_interface'),
5195            egress_filter=d.get('egress_filter'),
5196            healthy=d.get('healthy'),
5197            id=d.get('id'),
5198            keyfile=d.get('keyfile'),
5199            name=d.get('name'),
5200            scopes=d.get('scopes'),
5201            secret_store_id=d.get('secret_store_id'),
5202            tags=d.get('tags'),
5203        )
GCP( bind_interface=None, egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None)
5122    def __init__(
5123        self,
5124        bind_interface=None,
5125        egress_filter=None,
5126        healthy=None,
5127        id=None,
5128        keyfile=None,
5129        name=None,
5130        scopes=None,
5131        secret_store_id=None,
5132        tags=None,
5133    ):
5134        self.bind_interface = bind_interface if bind_interface is not None else ''
5135        '''
5136         Bind interface
5137        '''
5138        self.egress_filter = egress_filter if egress_filter is not None else ''
5139        '''
5140         A filter applied to the routing logic to pin datasource to nodes.
5141        '''
5142        self.healthy = healthy if healthy is not None else False
5143        '''
5144         True if the datasource is reachable and the credentials are valid.
5145        '''
5146        self.id = id if id is not None else ''
5147        '''
5148         Unique identifier of the Resource.
5149        '''
5150        self.keyfile = keyfile if keyfile is not None else ''
5151        self.name = name if name is not None else ''
5152        '''
5153         Unique human-readable name of the Resource.
5154        '''
5155        self.scopes = scopes if scopes is not None else ''
5156        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5157        '''
5158         ID of the secret store containing credentials for this resource, if any.
5159        '''
5160        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5161        '''
5162         Tags is a map of key, value pairs.
5163        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

keyfile
name

Unique human-readable name of the Resource.

scopes
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
5178    def to_dict(self):
5179        return {
5180            'bind_interface': self.bind_interface,
5181            'egress_filter': self.egress_filter,
5182            'healthy': self.healthy,
5183            'id': self.id,
5184            'keyfile': self.keyfile,
5185            'name': self.name,
5186            'scopes': self.scopes,
5187            'secret_store_id': self.secret_store_id,
5188            'tags': self.tags,
5189        }
@classmethod
def from_dict(cls, d)
5191    @classmethod
5192    def from_dict(cls, d):
5193        return cls(
5194            bind_interface=d.get('bind_interface'),
5195            egress_filter=d.get('egress_filter'),
5196            healthy=d.get('healthy'),
5197            id=d.get('id'),
5198            keyfile=d.get('keyfile'),
5199            name=d.get('name'),
5200            scopes=d.get('scopes'),
5201            secret_store_id=d.get('secret_store_id'),
5202            tags=d.get('tags'),
5203        )
class GCPStore:
5206class GCPStore:
5207    __slots__ = [
5208        'id',
5209        'name',
5210        'projectid',
5211        'tags',
5212    ]
5213
5214    def __init__(
5215        self,
5216        id=None,
5217        name=None,
5218        projectid=None,
5219        tags=None,
5220    ):
5221        self.id = id if id is not None else ''
5222        '''
5223         Unique identifier of the SecretStore.
5224        '''
5225        self.name = name if name is not None else ''
5226        '''
5227         Unique human-readable name of the SecretStore.
5228        '''
5229        self.projectid = projectid if projectid is not None else ''
5230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5231        '''
5232         Tags is a map of key, value pairs.
5233        '''
5234
5235    def __repr__(self):
5236        return '<sdm.GCPStore ' + \
5237            'id: ' + repr(self.id) + ' ' +\
5238            'name: ' + repr(self.name) + ' ' +\
5239            'projectid: ' + repr(self.projectid) + ' ' +\
5240            'tags: ' + repr(self.tags) + ' ' +\
5241            '>'
5242
5243    def to_dict(self):
5244        return {
5245            'id': self.id,
5246            'name': self.name,
5247            'projectid': self.projectid,
5248            'tags': self.tags,
5249        }
5250
5251    @classmethod
5252    def from_dict(cls, d):
5253        return cls(
5254            id=d.get('id'),
5255            name=d.get('name'),
5256            projectid=d.get('projectid'),
5257            tags=d.get('tags'),
5258        )
GCPStore(id=None, name=None, projectid=None, tags=None)
5214    def __init__(
5215        self,
5216        id=None,
5217        name=None,
5218        projectid=None,
5219        tags=None,
5220    ):
5221        self.id = id if id is not None else ''
5222        '''
5223         Unique identifier of the SecretStore.
5224        '''
5225        self.name = name if name is not None else ''
5226        '''
5227         Unique human-readable name of the SecretStore.
5228        '''
5229        self.projectid = projectid if projectid is not None else ''
5230        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5231        '''
5232         Tags is a map of key, value pairs.
5233        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

projectid
tags

Tags is a map of key, value pairs.

def to_dict(self)
5243    def to_dict(self):
5244        return {
5245            'id': self.id,
5246            'name': self.name,
5247            'projectid': self.projectid,
5248            'tags': self.tags,
5249        }
@classmethod
def from_dict(cls, d)
5251    @classmethod
5252    def from_dict(cls, d):
5253        return cls(
5254            id=d.get('id'),
5255            name=d.get('name'),
5256            projectid=d.get('projectid'),
5257            tags=d.get('tags'),
5258        )
class Gateway:
5261class Gateway:
5262    '''
5263         Gateway represents a StrongDM CLI installation running in gateway mode.
5264    '''
5265    __slots__ = [
5266        'bind_address',
5267        'device',
5268        'gateway_filter',
5269        'id',
5270        'listen_address',
5271        'location',
5272        'name',
5273        'state',
5274        'tags',
5275        'version',
5276    ]
5277
5278    def __init__(
5279        self,
5280        bind_address=None,
5281        device=None,
5282        gateway_filter=None,
5283        id=None,
5284        listen_address=None,
5285        location=None,
5286        name=None,
5287        state=None,
5288        tags=None,
5289        version=None,
5290    ):
5291        self.bind_address = bind_address if bind_address is not None else ''
5292        '''
5293         The hostname/port tuple which the gateway daemon will bind to.
5294         If not provided on create, set to "0.0.0.0:listen_address_port".
5295        '''
5296        self.device = device if device is not None else ''
5297        '''
5298         Device is a read only device name uploaded by the gateway process when 
5299         it comes online.
5300        '''
5301        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5302        '''
5303         GatewayFilter can be used to restrict the peering between relays and
5304         gateways.
5305        '''
5306        self.id = id if id is not None else ''
5307        '''
5308         Unique identifier of the Gateway.
5309        '''
5310        self.listen_address = listen_address if listen_address is not None else ''
5311        '''
5312         The public hostname/port tuple at which the gateway will be accessible to clients.
5313        '''
5314        self.location = location if location is not None else ''
5315        '''
5316         Location is a read only network location uploaded by the gateway process
5317         when it comes online.
5318        '''
5319        self.name = name if name is not None else ''
5320        '''
5321         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5322        '''
5323        self.state = state if state is not None else ''
5324        '''
5325         The current state of the gateway. One of: "new", "verifying_restart",
5326         "restarting", "started", "stopped", "dead", "unknown"
5327        '''
5328        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5329        '''
5330         Tags is a map of key, value pairs.
5331        '''
5332        self.version = version if version is not None else ''
5333        '''
5334         Version is a read only sdm binary version uploaded by the gateway process
5335         when it comes online.
5336        '''
5337
5338    def __repr__(self):
5339        return '<sdm.Gateway ' + \
5340            'bind_address: ' + repr(self.bind_address) + ' ' +\
5341            'device: ' + repr(self.device) + ' ' +\
5342            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
5343            'id: ' + repr(self.id) + ' ' +\
5344            'listen_address: ' + repr(self.listen_address) + ' ' +\
5345            'location: ' + repr(self.location) + ' ' +\
5346            'name: ' + repr(self.name) + ' ' +\
5347            'state: ' + repr(self.state) + ' ' +\
5348            'tags: ' + repr(self.tags) + ' ' +\
5349            'version: ' + repr(self.version) + ' ' +\
5350            '>'
5351
5352    def to_dict(self):
5353        return {
5354            'bind_address': self.bind_address,
5355            'device': self.device,
5356            'gateway_filter': self.gateway_filter,
5357            'id': self.id,
5358            'listen_address': self.listen_address,
5359            'location': self.location,
5360            'name': self.name,
5361            'state': self.state,
5362            'tags': self.tags,
5363            'version': self.version,
5364        }
5365
5366    @classmethod
5367    def from_dict(cls, d):
5368        return cls(
5369            bind_address=d.get('bind_address'),
5370            device=d.get('device'),
5371            gateway_filter=d.get('gateway_filter'),
5372            id=d.get('id'),
5373            listen_address=d.get('listen_address'),
5374            location=d.get('location'),
5375            name=d.get('name'),
5376            state=d.get('state'),
5377            tags=d.get('tags'),
5378            version=d.get('version'),
5379        )

Gateway represents a StrongDM CLI installation running in gateway mode.

Gateway( bind_address=None, device=None, gateway_filter=None, id=None, listen_address=None, location=None, name=None, state=None, tags=None, version=None)
5278    def __init__(
5279        self,
5280        bind_address=None,
5281        device=None,
5282        gateway_filter=None,
5283        id=None,
5284        listen_address=None,
5285        location=None,
5286        name=None,
5287        state=None,
5288        tags=None,
5289        version=None,
5290    ):
5291        self.bind_address = bind_address if bind_address is not None else ''
5292        '''
5293         The hostname/port tuple which the gateway daemon will bind to.
5294         If not provided on create, set to "0.0.0.0:listen_address_port".
5295        '''
5296        self.device = device if device is not None else ''
5297        '''
5298         Device is a read only device name uploaded by the gateway process when 
5299         it comes online.
5300        '''
5301        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5302        '''
5303         GatewayFilter can be used to restrict the peering between relays and
5304         gateways.
5305        '''
5306        self.id = id if id is not None else ''
5307        '''
5308         Unique identifier of the Gateway.
5309        '''
5310        self.listen_address = listen_address if listen_address is not None else ''
5311        '''
5312         The public hostname/port tuple at which the gateway will be accessible to clients.
5313        '''
5314        self.location = location if location is not None else ''
5315        '''
5316         Location is a read only network location uploaded by the gateway process
5317         when it comes online.
5318        '''
5319        self.name = name if name is not None else ''
5320        '''
5321         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5322        '''
5323        self.state = state if state is not None else ''
5324        '''
5325         The current state of the gateway. One of: "new", "verifying_restart",
5326         "restarting", "started", "stopped", "dead", "unknown"
5327        '''
5328        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5329        '''
5330         Tags is a map of key, value pairs.
5331        '''
5332        self.version = version if version is not None else ''
5333        '''
5334         Version is a read only sdm binary version uploaded by the gateway process
5335         when it comes online.
5336        '''
bind_address

The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".

device

Device is a read only device name uploaded by the gateway process when it comes online.

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Gateway.

listen_address

The public hostname/port tuple at which the gateway will be accessible to clients.

location

Location is a read only network location uploaded by the gateway process when it comes online.

name

Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"

tags

Tags is a map of key, value pairs.

version

Version is a read only sdm binary version uploaded by the gateway process when it comes online.

def to_dict(self)
5352    def to_dict(self):
5353        return {
5354            'bind_address': self.bind_address,
5355            'device': self.device,
5356            'gateway_filter': self.gateway_filter,
5357            'id': self.id,
5358            'listen_address': self.listen_address,
5359            'location': self.location,
5360            'name': self.name,
5361            'state': self.state,
5362            'tags': self.tags,
5363            'version': self.version,
5364        }
@classmethod
def from_dict(cls, d)
5366    @classmethod
5367    def from_dict(cls, d):
5368        return cls(
5369            bind_address=d.get('bind_address'),
5370            device=d.get('device'),
5371            gateway_filter=d.get('gateway_filter'),
5372            id=d.get('id'),
5373            listen_address=d.get('listen_address'),
5374            location=d.get('location'),
5375            name=d.get('name'),
5376            state=d.get('state'),
5377            tags=d.get('tags'),
5378            version=d.get('version'),
5379        )
class GetResponseMetadata:
5382class GetResponseMetadata:
5383    '''
5384         GetResponseMetadata is reserved for future use.
5385    '''
5386    __slots__ = []
5387
5388    def __init__(self, ):
5389        pass
5390
5391    def __repr__(self):
5392        return '<sdm.GetResponseMetadata ' + \
5393            '>'
5394
5395    def to_dict(self):
5396        return {}
5397
5398    @classmethod
5399    def from_dict(cls, d):
5400        return cls()

GetResponseMetadata is reserved for future use.

GetResponseMetadata()
5388    def __init__(self, ):
5389        pass
def to_dict(self)
5395    def to_dict(self):
5396        return {}
@classmethod
def from_dict(cls, d)
5398    @classmethod
5399    def from_dict(cls, d):
5400        return cls()
class GoogleGKE:
5403class GoogleGKE:
5404    __slots__ = [
5405        'bind_interface',
5406        'certificate_authority',
5407        'egress_filter',
5408        'endpoint',
5409        'healthcheck_namespace',
5410        'healthy',
5411        'id',
5412        'name',
5413        'remote_identity_group_id',
5414        'remote_identity_healthcheck_username',
5415        'secret_store_id',
5416        'service_account_key',
5417        'tags',
5418    ]
5419
5420    def __init__(
5421        self,
5422        bind_interface=None,
5423        certificate_authority=None,
5424        egress_filter=None,
5425        endpoint=None,
5426        healthcheck_namespace=None,
5427        healthy=None,
5428        id=None,
5429        name=None,
5430        remote_identity_group_id=None,
5431        remote_identity_healthcheck_username=None,
5432        secret_store_id=None,
5433        service_account_key=None,
5434        tags=None,
5435    ):
5436        self.bind_interface = bind_interface if bind_interface is not None else ''
5437        '''
5438         Bind interface
5439        '''
5440        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5441        self.egress_filter = egress_filter if egress_filter is not None else ''
5442        '''
5443         A filter applied to the routing logic to pin datasource to nodes.
5444        '''
5445        self.endpoint = endpoint if endpoint is not None else ''
5446        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5447        '''
5448         The path used to check the health of your connection.  Defaults to `default`.
5449        '''
5450        self.healthy = healthy if healthy is not None else False
5451        '''
5452         True if the datasource is reachable and the credentials are valid.
5453        '''
5454        self.id = id if id is not None else ''
5455        '''
5456         Unique identifier of the Resource.
5457        '''
5458        self.name = name if name is not None else ''
5459        '''
5460         Unique human-readable name of the Resource.
5461        '''
5462        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5463        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5464        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5465        '''
5466         ID of the secret store containing credentials for this resource, if any.
5467        '''
5468        self.service_account_key = service_account_key if service_account_key is not None else ''
5469        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5470        '''
5471         Tags is a map of key, value pairs.
5472        '''
5473
5474    def __repr__(self):
5475        return '<sdm.GoogleGKE ' + \
5476            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5477            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5478            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5479            'endpoint: ' + repr(self.endpoint) + ' ' +\
5480            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5481            'healthy: ' + repr(self.healthy) + ' ' +\
5482            'id: ' + repr(self.id) + ' ' +\
5483            'name: ' + repr(self.name) + ' ' +\
5484            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5485            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5486            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5487            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5488            'tags: ' + repr(self.tags) + ' ' +\
5489            '>'
5490
5491    def to_dict(self):
5492        return {
5493            'bind_interface': self.bind_interface,
5494            'certificate_authority': self.certificate_authority,
5495            'egress_filter': self.egress_filter,
5496            'endpoint': self.endpoint,
5497            'healthcheck_namespace': self.healthcheck_namespace,
5498            'healthy': self.healthy,
5499            'id': self.id,
5500            'name': self.name,
5501            'remote_identity_group_id': self.remote_identity_group_id,
5502            'remote_identity_healthcheck_username':
5503            self.remote_identity_healthcheck_username,
5504            'secret_store_id': self.secret_store_id,
5505            'service_account_key': self.service_account_key,
5506            'tags': self.tags,
5507        }
5508
5509    @classmethod
5510    def from_dict(cls, d):
5511        return cls(
5512            bind_interface=d.get('bind_interface'),
5513            certificate_authority=d.get('certificate_authority'),
5514            egress_filter=d.get('egress_filter'),
5515            endpoint=d.get('endpoint'),
5516            healthcheck_namespace=d.get('healthcheck_namespace'),
5517            healthy=d.get('healthy'),
5518            id=d.get('id'),
5519            name=d.get('name'),
5520            remote_identity_group_id=d.get('remote_identity_group_id'),
5521            remote_identity_healthcheck_username=d.get(
5522                'remote_identity_healthcheck_username'),
5523            secret_store_id=d.get('secret_store_id'),
5524            service_account_key=d.get('service_account_key'),
5525            tags=d.get('tags'),
5526        )
GoogleGKE( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, service_account_key=None, tags=None)
5420    def __init__(
5421        self,
5422        bind_interface=None,
5423        certificate_authority=None,
5424        egress_filter=None,
5425        endpoint=None,
5426        healthcheck_namespace=None,
5427        healthy=None,
5428        id=None,
5429        name=None,
5430        remote_identity_group_id=None,
5431        remote_identity_healthcheck_username=None,
5432        secret_store_id=None,
5433        service_account_key=None,
5434        tags=None,
5435    ):
5436        self.bind_interface = bind_interface if bind_interface is not None else ''
5437        '''
5438         Bind interface
5439        '''
5440        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5441        self.egress_filter = egress_filter if egress_filter is not None else ''
5442        '''
5443         A filter applied to the routing logic to pin datasource to nodes.
5444        '''
5445        self.endpoint = endpoint if endpoint is not None else ''
5446        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5447        '''
5448         The path used to check the health of your connection.  Defaults to `default`.
5449        '''
5450        self.healthy = healthy if healthy is not None else False
5451        '''
5452         True if the datasource is reachable and the credentials are valid.
5453        '''
5454        self.id = id if id is not None else ''
5455        '''
5456         Unique identifier of the Resource.
5457        '''
5458        self.name = name if name is not None else ''
5459        '''
5460         Unique human-readable name of the Resource.
5461        '''
5462        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5463        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5464        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5465        '''
5466         ID of the secret store containing credentials for this resource, if any.
5467        '''
5468        self.service_account_key = service_account_key if service_account_key is not None else ''
5469        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5470        '''
5471         Tags is a map of key, value pairs.
5472        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5491    def to_dict(self):
5492        return {
5493            'bind_interface': self.bind_interface,
5494            'certificate_authority': self.certificate_authority,
5495            'egress_filter': self.egress_filter,
5496            'endpoint': self.endpoint,
5497            'healthcheck_namespace': self.healthcheck_namespace,
5498            'healthy': self.healthy,
5499            'id': self.id,
5500            'name': self.name,
5501            'remote_identity_group_id': self.remote_identity_group_id,
5502            'remote_identity_healthcheck_username':
5503            self.remote_identity_healthcheck_username,
5504            'secret_store_id': self.secret_store_id,
5505            'service_account_key': self.service_account_key,
5506            'tags': self.tags,
5507        }
@classmethod
def from_dict(cls, d)
5509    @classmethod
5510    def from_dict(cls, d):
5511        return cls(
5512            bind_interface=d.get('bind_interface'),
5513            certificate_authority=d.get('certificate_authority'),
5514            egress_filter=d.get('egress_filter'),
5515            endpoint=d.get('endpoint'),
5516            healthcheck_namespace=d.get('healthcheck_namespace'),
5517            healthy=d.get('healthy'),
5518            id=d.get('id'),
5519            name=d.get('name'),
5520            remote_identity_group_id=d.get('remote_identity_group_id'),
5521            remote_identity_healthcheck_username=d.get(
5522                'remote_identity_healthcheck_username'),
5523            secret_store_id=d.get('secret_store_id'),
5524            service_account_key=d.get('service_account_key'),
5525            tags=d.get('tags'),
5526        )
class GoogleGKEUserImpersonation:
5529class GoogleGKEUserImpersonation:
5530    __slots__ = [
5531        'bind_interface',
5532        'certificate_authority',
5533        'egress_filter',
5534        'endpoint',
5535        'healthcheck_namespace',
5536        'healthy',
5537        'id',
5538        'name',
5539        'secret_store_id',
5540        'service_account_key',
5541        'tags',
5542    ]
5543
5544    def __init__(
5545        self,
5546        bind_interface=None,
5547        certificate_authority=None,
5548        egress_filter=None,
5549        endpoint=None,
5550        healthcheck_namespace=None,
5551        healthy=None,
5552        id=None,
5553        name=None,
5554        secret_store_id=None,
5555        service_account_key=None,
5556        tags=None,
5557    ):
5558        self.bind_interface = bind_interface if bind_interface is not None else ''
5559        '''
5560         Bind interface
5561        '''
5562        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5563        self.egress_filter = egress_filter if egress_filter is not None else ''
5564        '''
5565         A filter applied to the routing logic to pin datasource to nodes.
5566        '''
5567        self.endpoint = endpoint if endpoint is not None else ''
5568        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5569        '''
5570         The path used to check the health of your connection.  Defaults to `default`.
5571        '''
5572        self.healthy = healthy if healthy is not None else False
5573        '''
5574         True if the datasource is reachable and the credentials are valid.
5575        '''
5576        self.id = id if id is not None else ''
5577        '''
5578         Unique identifier of the Resource.
5579        '''
5580        self.name = name if name is not None else ''
5581        '''
5582         Unique human-readable name of the Resource.
5583        '''
5584        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5585        '''
5586         ID of the secret store containing credentials for this resource, if any.
5587        '''
5588        self.service_account_key = service_account_key if service_account_key is not None else ''
5589        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5590        '''
5591         Tags is a map of key, value pairs.
5592        '''
5593
5594    def __repr__(self):
5595        return '<sdm.GoogleGKEUserImpersonation ' + \
5596            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5597            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5598            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5599            'endpoint: ' + repr(self.endpoint) + ' ' +\
5600            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5601            'healthy: ' + repr(self.healthy) + ' ' +\
5602            'id: ' + repr(self.id) + ' ' +\
5603            'name: ' + repr(self.name) + ' ' +\
5604            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5605            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5606            'tags: ' + repr(self.tags) + ' ' +\
5607            '>'
5608
5609    def to_dict(self):
5610        return {
5611            'bind_interface': self.bind_interface,
5612            'certificate_authority': self.certificate_authority,
5613            'egress_filter': self.egress_filter,
5614            'endpoint': self.endpoint,
5615            'healthcheck_namespace': self.healthcheck_namespace,
5616            'healthy': self.healthy,
5617            'id': self.id,
5618            'name': self.name,
5619            'secret_store_id': self.secret_store_id,
5620            'service_account_key': self.service_account_key,
5621            'tags': self.tags,
5622        }
5623
5624    @classmethod
5625    def from_dict(cls, d):
5626        return cls(
5627            bind_interface=d.get('bind_interface'),
5628            certificate_authority=d.get('certificate_authority'),
5629            egress_filter=d.get('egress_filter'),
5630            endpoint=d.get('endpoint'),
5631            healthcheck_namespace=d.get('healthcheck_namespace'),
5632            healthy=d.get('healthy'),
5633            id=d.get('id'),
5634            name=d.get('name'),
5635            secret_store_id=d.get('secret_store_id'),
5636            service_account_key=d.get('service_account_key'),
5637            tags=d.get('tags'),
5638        )
GoogleGKEUserImpersonation( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None)
5544    def __init__(
5545        self,
5546        bind_interface=None,
5547        certificate_authority=None,
5548        egress_filter=None,
5549        endpoint=None,
5550        healthcheck_namespace=None,
5551        healthy=None,
5552        id=None,
5553        name=None,
5554        secret_store_id=None,
5555        service_account_key=None,
5556        tags=None,
5557    ):
5558        self.bind_interface = bind_interface if bind_interface is not None else ''
5559        '''
5560         Bind interface
5561        '''
5562        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5563        self.egress_filter = egress_filter if egress_filter is not None else ''
5564        '''
5565         A filter applied to the routing logic to pin datasource to nodes.
5566        '''
5567        self.endpoint = endpoint if endpoint is not None else ''
5568        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5569        '''
5570         The path used to check the health of your connection.  Defaults to `default`.
5571        '''
5572        self.healthy = healthy if healthy is not None else False
5573        '''
5574         True if the datasource is reachable and the credentials are valid.
5575        '''
5576        self.id = id if id is not None else ''
5577        '''
5578         Unique identifier of the Resource.
5579        '''
5580        self.name = name if name is not None else ''
5581        '''
5582         Unique human-readable name of the Resource.
5583        '''
5584        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5585        '''
5586         ID of the secret store containing credentials for this resource, if any.
5587        '''
5588        self.service_account_key = service_account_key if service_account_key is not None else ''
5589        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5590        '''
5591         Tags is a map of key, value pairs.
5592        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5609    def to_dict(self):
5610        return {
5611            'bind_interface': self.bind_interface,
5612            'certificate_authority': self.certificate_authority,
5613            'egress_filter': self.egress_filter,
5614            'endpoint': self.endpoint,
5615            'healthcheck_namespace': self.healthcheck_namespace,
5616            'healthy': self.healthy,
5617            'id': self.id,
5618            'name': self.name,
5619            'secret_store_id': self.secret_store_id,
5620            'service_account_key': self.service_account_key,
5621            'tags': self.tags,
5622        }
@classmethod
def from_dict(cls, d)
5624    @classmethod
5625    def from_dict(cls, d):
5626        return cls(
5627            bind_interface=d.get('bind_interface'),
5628            certificate_authority=d.get('certificate_authority'),
5629            egress_filter=d.get('egress_filter'),
5630            endpoint=d.get('endpoint'),
5631            healthcheck_namespace=d.get('healthcheck_namespace'),
5632            healthy=d.get('healthy'),
5633            id=d.get('id'),
5634            name=d.get('name'),
5635            secret_store_id=d.get('secret_store_id'),
5636            service_account_key=d.get('service_account_key'),
5637            tags=d.get('tags'),
5638        )
class Greenplum:
5641class Greenplum:
5642    __slots__ = [
5643        'bind_interface',
5644        'database',
5645        'egress_filter',
5646        'healthy',
5647        'hostname',
5648        'id',
5649        'name',
5650        'override_database',
5651        'password',
5652        'port',
5653        'port_override',
5654        'secret_store_id',
5655        'tags',
5656        'username',
5657    ]
5658
5659    def __init__(
5660        self,
5661        bind_interface=None,
5662        database=None,
5663        egress_filter=None,
5664        healthy=None,
5665        hostname=None,
5666        id=None,
5667        name=None,
5668        override_database=None,
5669        password=None,
5670        port=None,
5671        port_override=None,
5672        secret_store_id=None,
5673        tags=None,
5674        username=None,
5675    ):
5676        self.bind_interface = bind_interface if bind_interface is not None else ''
5677        '''
5678         Bind interface
5679        '''
5680        self.database = database if database is not None else ''
5681        self.egress_filter = egress_filter if egress_filter is not None else ''
5682        '''
5683         A filter applied to the routing logic to pin datasource to nodes.
5684        '''
5685        self.healthy = healthy if healthy is not None else False
5686        '''
5687         True if the datasource is reachable and the credentials are valid.
5688        '''
5689        self.hostname = hostname if hostname is not None else ''
5690        self.id = id if id is not None else ''
5691        '''
5692         Unique identifier of the Resource.
5693        '''
5694        self.name = name if name is not None else ''
5695        '''
5696         Unique human-readable name of the Resource.
5697        '''
5698        self.override_database = override_database if override_database is not None else False
5699        self.password = password if password is not None else ''
5700        self.port = port if port is not None else 0
5701        self.port_override = port_override if port_override is not None else 0
5702        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5703        '''
5704         ID of the secret store containing credentials for this resource, if any.
5705        '''
5706        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5707        '''
5708         Tags is a map of key, value pairs.
5709        '''
5710        self.username = username if username is not None else ''
5711
5712    def __repr__(self):
5713        return '<sdm.Greenplum ' + \
5714            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5715            'database: ' + repr(self.database) + ' ' +\
5716            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5717            'healthy: ' + repr(self.healthy) + ' ' +\
5718            'hostname: ' + repr(self.hostname) + ' ' +\
5719            'id: ' + repr(self.id) + ' ' +\
5720            'name: ' + repr(self.name) + ' ' +\
5721            'override_database: ' + repr(self.override_database) + ' ' +\
5722            'password: ' + repr(self.password) + ' ' +\
5723            'port: ' + repr(self.port) + ' ' +\
5724            'port_override: ' + repr(self.port_override) + ' ' +\
5725            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5726            'tags: ' + repr(self.tags) + ' ' +\
5727            'username: ' + repr(self.username) + ' ' +\
5728            '>'
5729
5730    def to_dict(self):
5731        return {
5732            'bind_interface': self.bind_interface,
5733            'database': self.database,
5734            'egress_filter': self.egress_filter,
5735            'healthy': self.healthy,
5736            'hostname': self.hostname,
5737            'id': self.id,
5738            'name': self.name,
5739            'override_database': self.override_database,
5740            'password': self.password,
5741            'port': self.port,
5742            'port_override': self.port_override,
5743            'secret_store_id': self.secret_store_id,
5744            'tags': self.tags,
5745            'username': self.username,
5746        }
5747
5748    @classmethod
5749    def from_dict(cls, d):
5750        return cls(
5751            bind_interface=d.get('bind_interface'),
5752            database=d.get('database'),
5753            egress_filter=d.get('egress_filter'),
5754            healthy=d.get('healthy'),
5755            hostname=d.get('hostname'),
5756            id=d.get('id'),
5757            name=d.get('name'),
5758            override_database=d.get('override_database'),
5759            password=d.get('password'),
5760            port=d.get('port'),
5761            port_override=d.get('port_override'),
5762            secret_store_id=d.get('secret_store_id'),
5763            tags=d.get('tags'),
5764            username=d.get('username'),
5765        )
Greenplum( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5659    def __init__(
5660        self,
5661        bind_interface=None,
5662        database=None,
5663        egress_filter=None,
5664        healthy=None,
5665        hostname=None,
5666        id=None,
5667        name=None,
5668        override_database=None,
5669        password=None,
5670        port=None,
5671        port_override=None,
5672        secret_store_id=None,
5673        tags=None,
5674        username=None,
5675    ):
5676        self.bind_interface = bind_interface if bind_interface is not None else ''
5677        '''
5678         Bind interface
5679        '''
5680        self.database = database if database is not None else ''
5681        self.egress_filter = egress_filter if egress_filter is not None else ''
5682        '''
5683         A filter applied to the routing logic to pin datasource to nodes.
5684        '''
5685        self.healthy = healthy if healthy is not None else False
5686        '''
5687         True if the datasource is reachable and the credentials are valid.
5688        '''
5689        self.hostname = hostname if hostname is not None else ''
5690        self.id = id if id is not None else ''
5691        '''
5692         Unique identifier of the Resource.
5693        '''
5694        self.name = name if name is not None else ''
5695        '''
5696         Unique human-readable name of the Resource.
5697        '''
5698        self.override_database = override_database if override_database is not None else False
5699        self.password = password if password is not None else ''
5700        self.port = port if port is not None else 0
5701        self.port_override = port_override if port_override is not None else 0
5702        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5703        '''
5704         ID of the secret store containing credentials for this resource, if any.
5705        '''
5706        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5707        '''
5708         Tags is a map of key, value pairs.
5709        '''
5710        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5730    def to_dict(self):
5731        return {
5732            'bind_interface': self.bind_interface,
5733            'database': self.database,
5734            'egress_filter': self.egress_filter,
5735            'healthy': self.healthy,
5736            'hostname': self.hostname,
5737            'id': self.id,
5738            'name': self.name,
5739            'override_database': self.override_database,
5740            'password': self.password,
5741            'port': self.port,
5742            'port_override': self.port_override,
5743            'secret_store_id': self.secret_store_id,
5744            'tags': self.tags,
5745            'username': self.username,
5746        }
@classmethod
def from_dict(cls, d)
5748    @classmethod
5749    def from_dict(cls, d):
5750        return cls(
5751            bind_interface=d.get('bind_interface'),
5752            database=d.get('database'),
5753            egress_filter=d.get('egress_filter'),
5754            healthy=d.get('healthy'),
5755            hostname=d.get('hostname'),
5756            id=d.get('id'),
5757            name=d.get('name'),
5758            override_database=d.get('override_database'),
5759            password=d.get('password'),
5760            port=d.get('port'),
5761            port_override=d.get('port_override'),
5762            secret_store_id=d.get('secret_store_id'),
5763            tags=d.get('tags'),
5764            username=d.get('username'),
5765        )
class HTTPAuth:
5768class HTTPAuth:
5769    __slots__ = [
5770        'auth_header',
5771        'bind_interface',
5772        'default_path',
5773        'egress_filter',
5774        'headers_blacklist',
5775        'healthcheck_path',
5776        'healthy',
5777        'host_override',
5778        'id',
5779        'name',
5780        'secret_store_id',
5781        'subdomain',
5782        'tags',
5783        'url',
5784    ]
5785
5786    def __init__(
5787        self,
5788        auth_header=None,
5789        bind_interface=None,
5790        default_path=None,
5791        egress_filter=None,
5792        headers_blacklist=None,
5793        healthcheck_path=None,
5794        healthy=None,
5795        host_override=None,
5796        id=None,
5797        name=None,
5798        secret_store_id=None,
5799        subdomain=None,
5800        tags=None,
5801        url=None,
5802    ):
5803        self.auth_header = auth_header if auth_header is not None else ''
5804        self.bind_interface = bind_interface if bind_interface is not None else ''
5805        '''
5806         Bind interface
5807        '''
5808        self.default_path = default_path if default_path is not None else ''
5809        self.egress_filter = egress_filter if egress_filter is not None else ''
5810        '''
5811         A filter applied to the routing logic to pin datasource to nodes.
5812        '''
5813        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5814        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5815        self.healthy = healthy if healthy is not None else False
5816        '''
5817         True if the datasource is reachable and the credentials are valid.
5818        '''
5819        self.host_override = host_override if host_override is not None else ''
5820        self.id = id if id is not None else ''
5821        '''
5822         Unique identifier of the Resource.
5823        '''
5824        self.name = name if name is not None else ''
5825        '''
5826         Unique human-readable name of the Resource.
5827        '''
5828        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5829        '''
5830         ID of the secret store containing credentials for this resource, if any.
5831        '''
5832        self.subdomain = subdomain if subdomain is not None else ''
5833        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5834        '''
5835         Tags is a map of key, value pairs.
5836        '''
5837        self.url = url if url is not None else ''
5838
5839    def __repr__(self):
5840        return '<sdm.HTTPAuth ' + \
5841            'auth_header: ' + repr(self.auth_header) + ' ' +\
5842            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5843            'default_path: ' + repr(self.default_path) + ' ' +\
5844            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5845            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5846            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5847            'healthy: ' + repr(self.healthy) + ' ' +\
5848            'host_override: ' + repr(self.host_override) + ' ' +\
5849            'id: ' + repr(self.id) + ' ' +\
5850            'name: ' + repr(self.name) + ' ' +\
5851            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5852            'subdomain: ' + repr(self.subdomain) + ' ' +\
5853            'tags: ' + repr(self.tags) + ' ' +\
5854            'url: ' + repr(self.url) + ' ' +\
5855            '>'
5856
5857    def to_dict(self):
5858        return {
5859            'auth_header': self.auth_header,
5860            'bind_interface': self.bind_interface,
5861            'default_path': self.default_path,
5862            'egress_filter': self.egress_filter,
5863            'headers_blacklist': self.headers_blacklist,
5864            'healthcheck_path': self.healthcheck_path,
5865            'healthy': self.healthy,
5866            'host_override': self.host_override,
5867            'id': self.id,
5868            'name': self.name,
5869            'secret_store_id': self.secret_store_id,
5870            'subdomain': self.subdomain,
5871            'tags': self.tags,
5872            'url': self.url,
5873        }
5874
5875    @classmethod
5876    def from_dict(cls, d):
5877        return cls(
5878            auth_header=d.get('auth_header'),
5879            bind_interface=d.get('bind_interface'),
5880            default_path=d.get('default_path'),
5881            egress_filter=d.get('egress_filter'),
5882            headers_blacklist=d.get('headers_blacklist'),
5883            healthcheck_path=d.get('healthcheck_path'),
5884            healthy=d.get('healthy'),
5885            host_override=d.get('host_override'),
5886            id=d.get('id'),
5887            name=d.get('name'),
5888            secret_store_id=d.get('secret_store_id'),
5889            subdomain=d.get('subdomain'),
5890            tags=d.get('tags'),
5891            url=d.get('url'),
5892        )
HTTPAuth( auth_header=None, bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5786    def __init__(
5787        self,
5788        auth_header=None,
5789        bind_interface=None,
5790        default_path=None,
5791        egress_filter=None,
5792        headers_blacklist=None,
5793        healthcheck_path=None,
5794        healthy=None,
5795        host_override=None,
5796        id=None,
5797        name=None,
5798        secret_store_id=None,
5799        subdomain=None,
5800        tags=None,
5801        url=None,
5802    ):
5803        self.auth_header = auth_header if auth_header is not None else ''
5804        self.bind_interface = bind_interface if bind_interface is not None else ''
5805        '''
5806         Bind interface
5807        '''
5808        self.default_path = default_path if default_path is not None else ''
5809        self.egress_filter = egress_filter if egress_filter is not None else ''
5810        '''
5811         A filter applied to the routing logic to pin datasource to nodes.
5812        '''
5813        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5814        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5815        self.healthy = healthy if healthy is not None else False
5816        '''
5817         True if the datasource is reachable and the credentials are valid.
5818        '''
5819        self.host_override = host_override if host_override is not None else ''
5820        self.id = id if id is not None else ''
5821        '''
5822         Unique identifier of the Resource.
5823        '''
5824        self.name = name if name is not None else ''
5825        '''
5826         Unique human-readable name of the Resource.
5827        '''
5828        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5829        '''
5830         ID of the secret store containing credentials for this resource, if any.
5831        '''
5832        self.subdomain = subdomain if subdomain is not None else ''
5833        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5834        '''
5835         Tags is a map of key, value pairs.
5836        '''
5837        self.url = url if url is not None else ''
auth_header
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5857    def to_dict(self):
5858        return {
5859            'auth_header': self.auth_header,
5860            'bind_interface': self.bind_interface,
5861            'default_path': self.default_path,
5862            'egress_filter': self.egress_filter,
5863            'headers_blacklist': self.headers_blacklist,
5864            'healthcheck_path': self.healthcheck_path,
5865            'healthy': self.healthy,
5866            'host_override': self.host_override,
5867            'id': self.id,
5868            'name': self.name,
5869            'secret_store_id': self.secret_store_id,
5870            'subdomain': self.subdomain,
5871            'tags': self.tags,
5872            'url': self.url,
5873        }
@classmethod
def from_dict(cls, d)
5875    @classmethod
5876    def from_dict(cls, d):
5877        return cls(
5878            auth_header=d.get('auth_header'),
5879            bind_interface=d.get('bind_interface'),
5880            default_path=d.get('default_path'),
5881            egress_filter=d.get('egress_filter'),
5882            headers_blacklist=d.get('headers_blacklist'),
5883            healthcheck_path=d.get('healthcheck_path'),
5884            healthy=d.get('healthy'),
5885            host_override=d.get('host_override'),
5886            id=d.get('id'),
5887            name=d.get('name'),
5888            secret_store_id=d.get('secret_store_id'),
5889            subdomain=d.get('subdomain'),
5890            tags=d.get('tags'),
5891            url=d.get('url'),
5892        )
class HTTPBasicAuth:
5895class HTTPBasicAuth:
5896    __slots__ = [
5897        'bind_interface',
5898        'default_path',
5899        'egress_filter',
5900        'headers_blacklist',
5901        'healthcheck_path',
5902        'healthy',
5903        'host_override',
5904        'id',
5905        'name',
5906        'password',
5907        'secret_store_id',
5908        'subdomain',
5909        'tags',
5910        'url',
5911        'username',
5912    ]
5913
5914    def __init__(
5915        self,
5916        bind_interface=None,
5917        default_path=None,
5918        egress_filter=None,
5919        headers_blacklist=None,
5920        healthcheck_path=None,
5921        healthy=None,
5922        host_override=None,
5923        id=None,
5924        name=None,
5925        password=None,
5926        secret_store_id=None,
5927        subdomain=None,
5928        tags=None,
5929        url=None,
5930        username=None,
5931    ):
5932        self.bind_interface = bind_interface if bind_interface is not None else ''
5933        '''
5934         Bind interface
5935        '''
5936        self.default_path = default_path if default_path is not None else ''
5937        self.egress_filter = egress_filter if egress_filter is not None else ''
5938        '''
5939         A filter applied to the routing logic to pin datasource to nodes.
5940        '''
5941        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5942        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5943        self.healthy = healthy if healthy is not None else False
5944        '''
5945         True if the datasource is reachable and the credentials are valid.
5946        '''
5947        self.host_override = host_override if host_override is not None else ''
5948        self.id = id if id is not None else ''
5949        '''
5950         Unique identifier of the Resource.
5951        '''
5952        self.name = name if name is not None else ''
5953        '''
5954         Unique human-readable name of the Resource.
5955        '''
5956        self.password = password if password is not None else ''
5957        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5958        '''
5959         ID of the secret store containing credentials for this resource, if any.
5960        '''
5961        self.subdomain = subdomain if subdomain is not None else ''
5962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5963        '''
5964         Tags is a map of key, value pairs.
5965        '''
5966        self.url = url if url is not None else ''
5967        self.username = username if username is not None else ''
5968
5969    def __repr__(self):
5970        return '<sdm.HTTPBasicAuth ' + \
5971            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5972            'default_path: ' + repr(self.default_path) + ' ' +\
5973            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5974            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5975            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5976            'healthy: ' + repr(self.healthy) + ' ' +\
5977            'host_override: ' + repr(self.host_override) + ' ' +\
5978            'id: ' + repr(self.id) + ' ' +\
5979            'name: ' + repr(self.name) + ' ' +\
5980            'password: ' + repr(self.password) + ' ' +\
5981            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5982            'subdomain: ' + repr(self.subdomain) + ' ' +\
5983            'tags: ' + repr(self.tags) + ' ' +\
5984            'url: ' + repr(self.url) + ' ' +\
5985            'username: ' + repr(self.username) + ' ' +\
5986            '>'
5987
5988    def to_dict(self):
5989        return {
5990            'bind_interface': self.bind_interface,
5991            'default_path': self.default_path,
5992            'egress_filter': self.egress_filter,
5993            'headers_blacklist': self.headers_blacklist,
5994            'healthcheck_path': self.healthcheck_path,
5995            'healthy': self.healthy,
5996            'host_override': self.host_override,
5997            'id': self.id,
5998            'name': self.name,
5999            'password': self.password,
6000            'secret_store_id': self.secret_store_id,
6001            'subdomain': self.subdomain,
6002            'tags': self.tags,
6003            'url': self.url,
6004            'username': self.username,
6005        }
6006
6007    @classmethod
6008    def from_dict(cls, d):
6009        return cls(
6010            bind_interface=d.get('bind_interface'),
6011            default_path=d.get('default_path'),
6012            egress_filter=d.get('egress_filter'),
6013            headers_blacklist=d.get('headers_blacklist'),
6014            healthcheck_path=d.get('healthcheck_path'),
6015            healthy=d.get('healthy'),
6016            host_override=d.get('host_override'),
6017            id=d.get('id'),
6018            name=d.get('name'),
6019            password=d.get('password'),
6020            secret_store_id=d.get('secret_store_id'),
6021            subdomain=d.get('subdomain'),
6022            tags=d.get('tags'),
6023            url=d.get('url'),
6024            username=d.get('username'),
6025        )
HTTPBasicAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None)
5914    def __init__(
5915        self,
5916        bind_interface=None,
5917        default_path=None,
5918        egress_filter=None,
5919        headers_blacklist=None,
5920        healthcheck_path=None,
5921        healthy=None,
5922        host_override=None,
5923        id=None,
5924        name=None,
5925        password=None,
5926        secret_store_id=None,
5927        subdomain=None,
5928        tags=None,
5929        url=None,
5930        username=None,
5931    ):
5932        self.bind_interface = bind_interface if bind_interface is not None else ''
5933        '''
5934         Bind interface
5935        '''
5936        self.default_path = default_path if default_path is not None else ''
5937        self.egress_filter = egress_filter if egress_filter is not None else ''
5938        '''
5939         A filter applied to the routing logic to pin datasource to nodes.
5940        '''
5941        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5942        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5943        self.healthy = healthy if healthy is not None else False
5944        '''
5945         True if the datasource is reachable and the credentials are valid.
5946        '''
5947        self.host_override = host_override if host_override is not None else ''
5948        self.id = id if id is not None else ''
5949        '''
5950         Unique identifier of the Resource.
5951        '''
5952        self.name = name if name is not None else ''
5953        '''
5954         Unique human-readable name of the Resource.
5955        '''
5956        self.password = password if password is not None else ''
5957        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5958        '''
5959         ID of the secret store containing credentials for this resource, if any.
5960        '''
5961        self.subdomain = subdomain if subdomain is not None else ''
5962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5963        '''
5964         Tags is a map of key, value pairs.
5965        '''
5966        self.url = url if url is not None else ''
5967        self.username = username if username is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
username
def to_dict(self)
5988    def to_dict(self):
5989        return {
5990            'bind_interface': self.bind_interface,
5991            'default_path': self.default_path,
5992            'egress_filter': self.egress_filter,
5993            'headers_blacklist': self.headers_blacklist,
5994            'healthcheck_path': self.healthcheck_path,
5995            'healthy': self.healthy,
5996            'host_override': self.host_override,
5997            'id': self.id,
5998            'name': self.name,
5999            'password': self.password,
6000            'secret_store_id': self.secret_store_id,
6001            'subdomain': self.subdomain,
6002            'tags': self.tags,
6003            'url': self.url,
6004            'username': self.username,
6005        }
@classmethod
def from_dict(cls, d)
6007    @classmethod
6008    def from_dict(cls, d):
6009        return cls(
6010            bind_interface=d.get('bind_interface'),
6011            default_path=d.get('default_path'),
6012            egress_filter=d.get('egress_filter'),
6013            headers_blacklist=d.get('headers_blacklist'),
6014            healthcheck_path=d.get('healthcheck_path'),
6015            healthy=d.get('healthy'),
6016            host_override=d.get('host_override'),
6017            id=d.get('id'),
6018            name=d.get('name'),
6019            password=d.get('password'),
6020            secret_store_id=d.get('secret_store_id'),
6021            subdomain=d.get('subdomain'),
6022            tags=d.get('tags'),
6023            url=d.get('url'),
6024            username=d.get('username'),
6025        )
class HTTPNoAuth:
6028class HTTPNoAuth:
6029    __slots__ = [
6030        'bind_interface',
6031        'default_path',
6032        'egress_filter',
6033        'headers_blacklist',
6034        'healthcheck_path',
6035        'healthy',
6036        'host_override',
6037        'id',
6038        'name',
6039        'secret_store_id',
6040        'subdomain',
6041        'tags',
6042        'url',
6043    ]
6044
6045    def __init__(
6046        self,
6047        bind_interface=None,
6048        default_path=None,
6049        egress_filter=None,
6050        headers_blacklist=None,
6051        healthcheck_path=None,
6052        healthy=None,
6053        host_override=None,
6054        id=None,
6055        name=None,
6056        secret_store_id=None,
6057        subdomain=None,
6058        tags=None,
6059        url=None,
6060    ):
6061        self.bind_interface = bind_interface if bind_interface is not None else ''
6062        '''
6063         Bind interface
6064        '''
6065        self.default_path = default_path if default_path is not None else ''
6066        self.egress_filter = egress_filter if egress_filter is not None else ''
6067        '''
6068         A filter applied to the routing logic to pin datasource to nodes.
6069        '''
6070        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6071        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6072        self.healthy = healthy if healthy is not None else False
6073        '''
6074         True if the datasource is reachable and the credentials are valid.
6075        '''
6076        self.host_override = host_override if host_override is not None else ''
6077        self.id = id if id is not None else ''
6078        '''
6079         Unique identifier of the Resource.
6080        '''
6081        self.name = name if name is not None else ''
6082        '''
6083         Unique human-readable name of the Resource.
6084        '''
6085        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6086        '''
6087         ID of the secret store containing credentials for this resource, if any.
6088        '''
6089        self.subdomain = subdomain if subdomain is not None else ''
6090        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6091        '''
6092         Tags is a map of key, value pairs.
6093        '''
6094        self.url = url if url is not None else ''
6095
6096    def __repr__(self):
6097        return '<sdm.HTTPNoAuth ' + \
6098            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6099            'default_path: ' + repr(self.default_path) + ' ' +\
6100            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6101            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6102            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6103            'healthy: ' + repr(self.healthy) + ' ' +\
6104            'host_override: ' + repr(self.host_override) + ' ' +\
6105            'id: ' + repr(self.id) + ' ' +\
6106            'name: ' + repr(self.name) + ' ' +\
6107            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6108            'subdomain: ' + repr(self.subdomain) + ' ' +\
6109            'tags: ' + repr(self.tags) + ' ' +\
6110            'url: ' + repr(self.url) + ' ' +\
6111            '>'
6112
6113    def to_dict(self):
6114        return {
6115            'bind_interface': self.bind_interface,
6116            'default_path': self.default_path,
6117            'egress_filter': self.egress_filter,
6118            'headers_blacklist': self.headers_blacklist,
6119            'healthcheck_path': self.healthcheck_path,
6120            'healthy': self.healthy,
6121            'host_override': self.host_override,
6122            'id': self.id,
6123            'name': self.name,
6124            'secret_store_id': self.secret_store_id,
6125            'subdomain': self.subdomain,
6126            'tags': self.tags,
6127            'url': self.url,
6128        }
6129
6130    @classmethod
6131    def from_dict(cls, d):
6132        return cls(
6133            bind_interface=d.get('bind_interface'),
6134            default_path=d.get('default_path'),
6135            egress_filter=d.get('egress_filter'),
6136            headers_blacklist=d.get('headers_blacklist'),
6137            healthcheck_path=d.get('healthcheck_path'),
6138            healthy=d.get('healthy'),
6139            host_override=d.get('host_override'),
6140            id=d.get('id'),
6141            name=d.get('name'),
6142            secret_store_id=d.get('secret_store_id'),
6143            subdomain=d.get('subdomain'),
6144            tags=d.get('tags'),
6145            url=d.get('url'),
6146        )
HTTPNoAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, host_override=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
6045    def __init__(
6046        self,
6047        bind_interface=None,
6048        default_path=None,
6049        egress_filter=None,
6050        headers_blacklist=None,
6051        healthcheck_path=None,
6052        healthy=None,
6053        host_override=None,
6054        id=None,
6055        name=None,
6056        secret_store_id=None,
6057        subdomain=None,
6058        tags=None,
6059        url=None,
6060    ):
6061        self.bind_interface = bind_interface if bind_interface is not None else ''
6062        '''
6063         Bind interface
6064        '''
6065        self.default_path = default_path if default_path is not None else ''
6066        self.egress_filter = egress_filter if egress_filter is not None else ''
6067        '''
6068         A filter applied to the routing logic to pin datasource to nodes.
6069        '''
6070        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6071        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6072        self.healthy = healthy if healthy is not None else False
6073        '''
6074         True if the datasource is reachable and the credentials are valid.
6075        '''
6076        self.host_override = host_override if host_override is not None else ''
6077        self.id = id if id is not None else ''
6078        '''
6079         Unique identifier of the Resource.
6080        '''
6081        self.name = name if name is not None else ''
6082        '''
6083         Unique human-readable name of the Resource.
6084        '''
6085        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6086        '''
6087         ID of the secret store containing credentials for this resource, if any.
6088        '''
6089        self.subdomain = subdomain if subdomain is not None else ''
6090        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6091        '''
6092         Tags is a map of key, value pairs.
6093        '''
6094        self.url = url if url is not None else ''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

host_override
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
6113    def to_dict(self):
6114        return {
6115            'bind_interface': self.bind_interface,
6116            'default_path': self.default_path,
6117            'egress_filter': self.egress_filter,
6118            'headers_blacklist': self.headers_blacklist,
6119            'healthcheck_path': self.healthcheck_path,
6120            'healthy': self.healthy,
6121            'host_override': self.host_override,
6122            'id': self.id,
6123            'name': self.name,
6124            'secret_store_id': self.secret_store_id,
6125            'subdomain': self.subdomain,
6126            'tags': self.tags,
6127            'url': self.url,
6128        }
@classmethod
def from_dict(cls, d)
6130    @classmethod
6131    def from_dict(cls, d):
6132        return cls(
6133            bind_interface=d.get('bind_interface'),
6134            default_path=d.get('default_path'),
6135            egress_filter=d.get('egress_filter'),
6136            headers_blacklist=d.get('headers_blacklist'),
6137            healthcheck_path=d.get('healthcheck_path'),
6138            healthy=d.get('healthy'),
6139            host_override=d.get('host_override'),
6140            id=d.get('id'),
6141            name=d.get('name'),
6142            secret_store_id=d.get('secret_store_id'),
6143            subdomain=d.get('subdomain'),
6144            tags=d.get('tags'),
6145            url=d.get('url'),
6146        )
class Kubernetes:
6149class Kubernetes:
6150    __slots__ = [
6151        'bind_interface',
6152        'certificate_authority',
6153        'client_certificate',
6154        'client_key',
6155        'egress_filter',
6156        'healthcheck_namespace',
6157        'healthy',
6158        'hostname',
6159        'id',
6160        'name',
6161        'port',
6162        'port_override',
6163        'remote_identity_group_id',
6164        'remote_identity_healthcheck_username',
6165        'secret_store_id',
6166        'tags',
6167    ]
6168
6169    def __init__(
6170        self,
6171        bind_interface=None,
6172        certificate_authority=None,
6173        client_certificate=None,
6174        client_key=None,
6175        egress_filter=None,
6176        healthcheck_namespace=None,
6177        healthy=None,
6178        hostname=None,
6179        id=None,
6180        name=None,
6181        port=None,
6182        port_override=None,
6183        remote_identity_group_id=None,
6184        remote_identity_healthcheck_username=None,
6185        secret_store_id=None,
6186        tags=None,
6187    ):
6188        self.bind_interface = bind_interface if bind_interface is not None else ''
6189        '''
6190         Bind interface
6191        '''
6192        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6193        self.client_certificate = client_certificate if client_certificate is not None else ''
6194        self.client_key = client_key if client_key is not None else ''
6195        self.egress_filter = egress_filter if egress_filter is not None else ''
6196        '''
6197         A filter applied to the routing logic to pin datasource to nodes.
6198        '''
6199        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6200        '''
6201         The path used to check the health of your connection.  Defaults to `default`.
6202        '''
6203        self.healthy = healthy if healthy is not None else False
6204        '''
6205         True if the datasource is reachable and the credentials are valid.
6206        '''
6207        self.hostname = hostname if hostname is not None else ''
6208        self.id = id if id is not None else ''
6209        '''
6210         Unique identifier of the Resource.
6211        '''
6212        self.name = name if name is not None else ''
6213        '''
6214         Unique human-readable name of the Resource.
6215        '''
6216        self.port = port if port is not None else 0
6217        self.port_override = port_override if port_override is not None else 0
6218        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6219        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6220        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6221        '''
6222         ID of the secret store containing credentials for this resource, if any.
6223        '''
6224        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6225        '''
6226         Tags is a map of key, value pairs.
6227        '''
6228
6229    def __repr__(self):
6230        return '<sdm.Kubernetes ' + \
6231            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6232            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6233            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6234            'client_key: ' + repr(self.client_key) + ' ' +\
6235            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6236            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6237            'healthy: ' + repr(self.healthy) + ' ' +\
6238            'hostname: ' + repr(self.hostname) + ' ' +\
6239            'id: ' + repr(self.id) + ' ' +\
6240            'name: ' + repr(self.name) + ' ' +\
6241            'port: ' + repr(self.port) + ' ' +\
6242            'port_override: ' + repr(self.port_override) + ' ' +\
6243            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6244            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6245            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6246            'tags: ' + repr(self.tags) + ' ' +\
6247            '>'
6248
6249    def to_dict(self):
6250        return {
6251            'bind_interface': self.bind_interface,
6252            'certificate_authority': self.certificate_authority,
6253            'client_certificate': self.client_certificate,
6254            'client_key': self.client_key,
6255            'egress_filter': self.egress_filter,
6256            'healthcheck_namespace': self.healthcheck_namespace,
6257            'healthy': self.healthy,
6258            'hostname': self.hostname,
6259            'id': self.id,
6260            'name': self.name,
6261            'port': self.port,
6262            'port_override': self.port_override,
6263            'remote_identity_group_id': self.remote_identity_group_id,
6264            'remote_identity_healthcheck_username':
6265            self.remote_identity_healthcheck_username,
6266            'secret_store_id': self.secret_store_id,
6267            'tags': self.tags,
6268        }
6269
6270    @classmethod
6271    def from_dict(cls, d):
6272        return cls(
6273            bind_interface=d.get('bind_interface'),
6274            certificate_authority=d.get('certificate_authority'),
6275            client_certificate=d.get('client_certificate'),
6276            client_key=d.get('client_key'),
6277            egress_filter=d.get('egress_filter'),
6278            healthcheck_namespace=d.get('healthcheck_namespace'),
6279            healthy=d.get('healthy'),
6280            hostname=d.get('hostname'),
6281            id=d.get('id'),
6282            name=d.get('name'),
6283            port=d.get('port'),
6284            port_override=d.get('port_override'),
6285            remote_identity_group_id=d.get('remote_identity_group_id'),
6286            remote_identity_healthcheck_username=d.get(
6287                'remote_identity_healthcheck_username'),
6288            secret_store_id=d.get('secret_store_id'),
6289            tags=d.get('tags'),
6290        )
Kubernetes( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
6169    def __init__(
6170        self,
6171        bind_interface=None,
6172        certificate_authority=None,
6173        client_certificate=None,
6174        client_key=None,
6175        egress_filter=None,
6176        healthcheck_namespace=None,
6177        healthy=None,
6178        hostname=None,
6179        id=None,
6180        name=None,
6181        port=None,
6182        port_override=None,
6183        remote_identity_group_id=None,
6184        remote_identity_healthcheck_username=None,
6185        secret_store_id=None,
6186        tags=None,
6187    ):
6188        self.bind_interface = bind_interface if bind_interface is not None else ''
6189        '''
6190         Bind interface
6191        '''
6192        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6193        self.client_certificate = client_certificate if client_certificate is not None else ''
6194        self.client_key = client_key if client_key is not None else ''
6195        self.egress_filter = egress_filter if egress_filter is not None else ''
6196        '''
6197         A filter applied to the routing logic to pin datasource to nodes.
6198        '''
6199        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6200        '''
6201         The path used to check the health of your connection.  Defaults to `default`.
6202        '''
6203        self.healthy = healthy if healthy is not None else False
6204        '''
6205         True if the datasource is reachable and the credentials are valid.
6206        '''
6207        self.hostname = hostname if hostname is not None else ''
6208        self.id = id if id is not None else ''
6209        '''
6210         Unique identifier of the Resource.
6211        '''
6212        self.name = name if name is not None else ''
6213        '''
6214         Unique human-readable name of the Resource.
6215        '''
6216        self.port = port if port is not None else 0
6217        self.port_override = port_override if port_override is not None else 0
6218        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6219        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6220        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6221        '''
6222         ID of the secret store containing credentials for this resource, if any.
6223        '''
6224        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6225        '''
6226         Tags is a map of key, value pairs.
6227        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6249    def to_dict(self):
6250        return {
6251            'bind_interface': self.bind_interface,
6252            'certificate_authority': self.certificate_authority,
6253            'client_certificate': self.client_certificate,
6254            'client_key': self.client_key,
6255            'egress_filter': self.egress_filter,
6256            'healthcheck_namespace': self.healthcheck_namespace,
6257            'healthy': self.healthy,
6258            'hostname': self.hostname,
6259            'id': self.id,
6260            'name': self.name,
6261            'port': self.port,
6262            'port_override': self.port_override,
6263            'remote_identity_group_id': self.remote_identity_group_id,
6264            'remote_identity_healthcheck_username':
6265            self.remote_identity_healthcheck_username,
6266            'secret_store_id': self.secret_store_id,
6267            'tags': self.tags,
6268        }
@classmethod
def from_dict(cls, d)
6270    @classmethod
6271    def from_dict(cls, d):
6272        return cls(
6273            bind_interface=d.get('bind_interface'),
6274            certificate_authority=d.get('certificate_authority'),
6275            client_certificate=d.get('client_certificate'),
6276            client_key=d.get('client_key'),
6277            egress_filter=d.get('egress_filter'),
6278            healthcheck_namespace=d.get('healthcheck_namespace'),
6279            healthy=d.get('healthy'),
6280            hostname=d.get('hostname'),
6281            id=d.get('id'),
6282            name=d.get('name'),
6283            port=d.get('port'),
6284            port_override=d.get('port_override'),
6285            remote_identity_group_id=d.get('remote_identity_group_id'),
6286            remote_identity_healthcheck_username=d.get(
6287                'remote_identity_healthcheck_username'),
6288            secret_store_id=d.get('secret_store_id'),
6289            tags=d.get('tags'),
6290        )
class KubernetesBasicAuth:
6293class KubernetesBasicAuth:
6294    __slots__ = [
6295        'bind_interface',
6296        'egress_filter',
6297        'healthcheck_namespace',
6298        'healthy',
6299        'hostname',
6300        'id',
6301        'name',
6302        'password',
6303        'port',
6304        'port_override',
6305        'secret_store_id',
6306        'tags',
6307        'username',
6308    ]
6309
6310    def __init__(
6311        self,
6312        bind_interface=None,
6313        egress_filter=None,
6314        healthcheck_namespace=None,
6315        healthy=None,
6316        hostname=None,
6317        id=None,
6318        name=None,
6319        password=None,
6320        port=None,
6321        port_override=None,
6322        secret_store_id=None,
6323        tags=None,
6324        username=None,
6325    ):
6326        self.bind_interface = bind_interface if bind_interface is not None else ''
6327        '''
6328         Bind interface
6329        '''
6330        self.egress_filter = egress_filter if egress_filter is not None else ''
6331        '''
6332         A filter applied to the routing logic to pin datasource to nodes.
6333        '''
6334        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6335        '''
6336         The path used to check the health of your connection.  Defaults to `default`.
6337        '''
6338        self.healthy = healthy if healthy is not None else False
6339        '''
6340         True if the datasource is reachable and the credentials are valid.
6341        '''
6342        self.hostname = hostname if hostname is not None else ''
6343        self.id = id if id is not None else ''
6344        '''
6345         Unique identifier of the Resource.
6346        '''
6347        self.name = name if name is not None else ''
6348        '''
6349         Unique human-readable name of the Resource.
6350        '''
6351        self.password = password if password is not None else ''
6352        self.port = port if port is not None else 0
6353        self.port_override = port_override if port_override is not None else 0
6354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6355        '''
6356         ID of the secret store containing credentials for this resource, if any.
6357        '''
6358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6359        '''
6360         Tags is a map of key, value pairs.
6361        '''
6362        self.username = username if username is not None else ''
6363
6364    def __repr__(self):
6365        return '<sdm.KubernetesBasicAuth ' + \
6366            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6367            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6368            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6369            'healthy: ' + repr(self.healthy) + ' ' +\
6370            'hostname: ' + repr(self.hostname) + ' ' +\
6371            'id: ' + repr(self.id) + ' ' +\
6372            'name: ' + repr(self.name) + ' ' +\
6373            'password: ' + repr(self.password) + ' ' +\
6374            'port: ' + repr(self.port) + ' ' +\
6375            'port_override: ' + repr(self.port_override) + ' ' +\
6376            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6377            'tags: ' + repr(self.tags) + ' ' +\
6378            'username: ' + repr(self.username) + ' ' +\
6379            '>'
6380
6381    def to_dict(self):
6382        return {
6383            'bind_interface': self.bind_interface,
6384            'egress_filter': self.egress_filter,
6385            'healthcheck_namespace': self.healthcheck_namespace,
6386            'healthy': self.healthy,
6387            'hostname': self.hostname,
6388            'id': self.id,
6389            'name': self.name,
6390            'password': self.password,
6391            'port': self.port,
6392            'port_override': self.port_override,
6393            'secret_store_id': self.secret_store_id,
6394            'tags': self.tags,
6395            'username': self.username,
6396        }
6397
6398    @classmethod
6399    def from_dict(cls, d):
6400        return cls(
6401            bind_interface=d.get('bind_interface'),
6402            egress_filter=d.get('egress_filter'),
6403            healthcheck_namespace=d.get('healthcheck_namespace'),
6404            healthy=d.get('healthy'),
6405            hostname=d.get('hostname'),
6406            id=d.get('id'),
6407            name=d.get('name'),
6408            password=d.get('password'),
6409            port=d.get('port'),
6410            port_override=d.get('port_override'),
6411            secret_store_id=d.get('secret_store_id'),
6412            tags=d.get('tags'),
6413            username=d.get('username'),
6414        )
KubernetesBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
6310    def __init__(
6311        self,
6312        bind_interface=None,
6313        egress_filter=None,
6314        healthcheck_namespace=None,
6315        healthy=None,
6316        hostname=None,
6317        id=None,
6318        name=None,
6319        password=None,
6320        port=None,
6321        port_override=None,
6322        secret_store_id=None,
6323        tags=None,
6324        username=None,
6325    ):
6326        self.bind_interface = bind_interface if bind_interface is not None else ''
6327        '''
6328         Bind interface
6329        '''
6330        self.egress_filter = egress_filter if egress_filter is not None else ''
6331        '''
6332         A filter applied to the routing logic to pin datasource to nodes.
6333        '''
6334        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6335        '''
6336         The path used to check the health of your connection.  Defaults to `default`.
6337        '''
6338        self.healthy = healthy if healthy is not None else False
6339        '''
6340         True if the datasource is reachable and the credentials are valid.
6341        '''
6342        self.hostname = hostname if hostname is not None else ''
6343        self.id = id if id is not None else ''
6344        '''
6345         Unique identifier of the Resource.
6346        '''
6347        self.name = name if name is not None else ''
6348        '''
6349         Unique human-readable name of the Resource.
6350        '''
6351        self.password = password if password is not None else ''
6352        self.port = port if port is not None else 0
6353        self.port_override = port_override if port_override is not None else 0
6354        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6355        '''
6356         ID of the secret store containing credentials for this resource, if any.
6357        '''
6358        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6359        '''
6360         Tags is a map of key, value pairs.
6361        '''
6362        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6381    def to_dict(self):
6382        return {
6383            'bind_interface': self.bind_interface,
6384            'egress_filter': self.egress_filter,
6385            'healthcheck_namespace': self.healthcheck_namespace,
6386            'healthy': self.healthy,
6387            'hostname': self.hostname,
6388            'id': self.id,
6389            'name': self.name,
6390            'password': self.password,
6391            'port': self.port,
6392            'port_override': self.port_override,
6393            'secret_store_id': self.secret_store_id,
6394            'tags': self.tags,
6395            'username': self.username,
6396        }
@classmethod
def from_dict(cls, d)
6398    @classmethod
6399    def from_dict(cls, d):
6400        return cls(
6401            bind_interface=d.get('bind_interface'),
6402            egress_filter=d.get('egress_filter'),
6403            healthcheck_namespace=d.get('healthcheck_namespace'),
6404            healthy=d.get('healthy'),
6405            hostname=d.get('hostname'),
6406            id=d.get('id'),
6407            name=d.get('name'),
6408            password=d.get('password'),
6409            port=d.get('port'),
6410            port_override=d.get('port_override'),
6411            secret_store_id=d.get('secret_store_id'),
6412            tags=d.get('tags'),
6413            username=d.get('username'),
6414        )
class KubernetesServiceAccount:
6417class KubernetesServiceAccount:
6418    __slots__ = [
6419        'bind_interface',
6420        'egress_filter',
6421        'healthcheck_namespace',
6422        'healthy',
6423        'hostname',
6424        'id',
6425        'name',
6426        'port',
6427        'port_override',
6428        'remote_identity_group_id',
6429        'remote_identity_healthcheck_username',
6430        'secret_store_id',
6431        'tags',
6432        'token',
6433    ]
6434
6435    def __init__(
6436        self,
6437        bind_interface=None,
6438        egress_filter=None,
6439        healthcheck_namespace=None,
6440        healthy=None,
6441        hostname=None,
6442        id=None,
6443        name=None,
6444        port=None,
6445        port_override=None,
6446        remote_identity_group_id=None,
6447        remote_identity_healthcheck_username=None,
6448        secret_store_id=None,
6449        tags=None,
6450        token=None,
6451    ):
6452        self.bind_interface = bind_interface if bind_interface is not None else ''
6453        '''
6454         Bind interface
6455        '''
6456        self.egress_filter = egress_filter if egress_filter is not None else ''
6457        '''
6458         A filter applied to the routing logic to pin datasource to nodes.
6459        '''
6460        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6461        '''
6462         The path used to check the health of your connection.  Defaults to `default`.
6463        '''
6464        self.healthy = healthy if healthy is not None else False
6465        '''
6466         True if the datasource is reachable and the credentials are valid.
6467        '''
6468        self.hostname = hostname if hostname is not None else ''
6469        self.id = id if id is not None else ''
6470        '''
6471         Unique identifier of the Resource.
6472        '''
6473        self.name = name if name is not None else ''
6474        '''
6475         Unique human-readable name of the Resource.
6476        '''
6477        self.port = port if port is not None else 0
6478        self.port_override = port_override if port_override is not None else 0
6479        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6480        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6481        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6482        '''
6483         ID of the secret store containing credentials for this resource, if any.
6484        '''
6485        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6486        '''
6487         Tags is a map of key, value pairs.
6488        '''
6489        self.token = token if token is not None else ''
6490
6491    def __repr__(self):
6492        return '<sdm.KubernetesServiceAccount ' + \
6493            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6494            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6495            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6496            'healthy: ' + repr(self.healthy) + ' ' +\
6497            'hostname: ' + repr(self.hostname) + ' ' +\
6498            'id: ' + repr(self.id) + ' ' +\
6499            'name: ' + repr(self.name) + ' ' +\
6500            'port: ' + repr(self.port) + ' ' +\
6501            'port_override: ' + repr(self.port_override) + ' ' +\
6502            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6503            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6504            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6505            'tags: ' + repr(self.tags) + ' ' +\
6506            'token: ' + repr(self.token) + ' ' +\
6507            '>'
6508
6509    def to_dict(self):
6510        return {
6511            'bind_interface': self.bind_interface,
6512            'egress_filter': self.egress_filter,
6513            'healthcheck_namespace': self.healthcheck_namespace,
6514            'healthy': self.healthy,
6515            'hostname': self.hostname,
6516            'id': self.id,
6517            'name': self.name,
6518            'port': self.port,
6519            'port_override': self.port_override,
6520            'remote_identity_group_id': self.remote_identity_group_id,
6521            'remote_identity_healthcheck_username':
6522            self.remote_identity_healthcheck_username,
6523            'secret_store_id': self.secret_store_id,
6524            'tags': self.tags,
6525            'token': self.token,
6526        }
6527
6528    @classmethod
6529    def from_dict(cls, d):
6530        return cls(
6531            bind_interface=d.get('bind_interface'),
6532            egress_filter=d.get('egress_filter'),
6533            healthcheck_namespace=d.get('healthcheck_namespace'),
6534            healthy=d.get('healthy'),
6535            hostname=d.get('hostname'),
6536            id=d.get('id'),
6537            name=d.get('name'),
6538            port=d.get('port'),
6539            port_override=d.get('port_override'),
6540            remote_identity_group_id=d.get('remote_identity_group_id'),
6541            remote_identity_healthcheck_username=d.get(
6542                'remote_identity_healthcheck_username'),
6543            secret_store_id=d.get('secret_store_id'),
6544            tags=d.get('tags'),
6545            token=d.get('token'),
6546        )
KubernetesServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
6435    def __init__(
6436        self,
6437        bind_interface=None,
6438        egress_filter=None,
6439        healthcheck_namespace=None,
6440        healthy=None,
6441        hostname=None,
6442        id=None,
6443        name=None,
6444        port=None,
6445        port_override=None,
6446        remote_identity_group_id=None,
6447        remote_identity_healthcheck_username=None,
6448        secret_store_id=None,
6449        tags=None,
6450        token=None,
6451    ):
6452        self.bind_interface = bind_interface if bind_interface is not None else ''
6453        '''
6454         Bind interface
6455        '''
6456        self.egress_filter = egress_filter if egress_filter is not None else ''
6457        '''
6458         A filter applied to the routing logic to pin datasource to nodes.
6459        '''
6460        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6461        '''
6462         The path used to check the health of your connection.  Defaults to `default`.
6463        '''
6464        self.healthy = healthy if healthy is not None else False
6465        '''
6466         True if the datasource is reachable and the credentials are valid.
6467        '''
6468        self.hostname = hostname if hostname is not None else ''
6469        self.id = id if id is not None else ''
6470        '''
6471         Unique identifier of the Resource.
6472        '''
6473        self.name = name if name is not None else ''
6474        '''
6475         Unique human-readable name of the Resource.
6476        '''
6477        self.port = port if port is not None else 0
6478        self.port_override = port_override if port_override is not None else 0
6479        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6480        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6481        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6482        '''
6483         ID of the secret store containing credentials for this resource, if any.
6484        '''
6485        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6486        '''
6487         Tags is a map of key, value pairs.
6488        '''
6489        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6509    def to_dict(self):
6510        return {
6511            'bind_interface': self.bind_interface,
6512            'egress_filter': self.egress_filter,
6513            'healthcheck_namespace': self.healthcheck_namespace,
6514            'healthy': self.healthy,
6515            'hostname': self.hostname,
6516            'id': self.id,
6517            'name': self.name,
6518            'port': self.port,
6519            'port_override': self.port_override,
6520            'remote_identity_group_id': self.remote_identity_group_id,
6521            'remote_identity_healthcheck_username':
6522            self.remote_identity_healthcheck_username,
6523            'secret_store_id': self.secret_store_id,
6524            'tags': self.tags,
6525            'token': self.token,
6526        }
@classmethod
def from_dict(cls, d)
6528    @classmethod
6529    def from_dict(cls, d):
6530        return cls(
6531            bind_interface=d.get('bind_interface'),
6532            egress_filter=d.get('egress_filter'),
6533            healthcheck_namespace=d.get('healthcheck_namespace'),
6534            healthy=d.get('healthy'),
6535            hostname=d.get('hostname'),
6536            id=d.get('id'),
6537            name=d.get('name'),
6538            port=d.get('port'),
6539            port_override=d.get('port_override'),
6540            remote_identity_group_id=d.get('remote_identity_group_id'),
6541            remote_identity_healthcheck_username=d.get(
6542                'remote_identity_healthcheck_username'),
6543            secret_store_id=d.get('secret_store_id'),
6544            tags=d.get('tags'),
6545            token=d.get('token'),
6546        )
class KubernetesServiceAccountUserImpersonation:
6549class KubernetesServiceAccountUserImpersonation:
6550    __slots__ = [
6551        'bind_interface',
6552        'egress_filter',
6553        'healthcheck_namespace',
6554        'healthy',
6555        'hostname',
6556        'id',
6557        'name',
6558        'port',
6559        'port_override',
6560        'secret_store_id',
6561        'tags',
6562        'token',
6563    ]
6564
6565    def __init__(
6566        self,
6567        bind_interface=None,
6568        egress_filter=None,
6569        healthcheck_namespace=None,
6570        healthy=None,
6571        hostname=None,
6572        id=None,
6573        name=None,
6574        port=None,
6575        port_override=None,
6576        secret_store_id=None,
6577        tags=None,
6578        token=None,
6579    ):
6580        self.bind_interface = bind_interface if bind_interface is not None else ''
6581        '''
6582         Bind interface
6583        '''
6584        self.egress_filter = egress_filter if egress_filter is not None else ''
6585        '''
6586         A filter applied to the routing logic to pin datasource to nodes.
6587        '''
6588        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6589        '''
6590         The path used to check the health of your connection.  Defaults to `default`.
6591        '''
6592        self.healthy = healthy if healthy is not None else False
6593        '''
6594         True if the datasource is reachable and the credentials are valid.
6595        '''
6596        self.hostname = hostname if hostname is not None else ''
6597        self.id = id if id is not None else ''
6598        '''
6599         Unique identifier of the Resource.
6600        '''
6601        self.name = name if name is not None else ''
6602        '''
6603         Unique human-readable name of the Resource.
6604        '''
6605        self.port = port if port is not None else 0
6606        self.port_override = port_override if port_override is not None else 0
6607        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6608        '''
6609         ID of the secret store containing credentials for this resource, if any.
6610        '''
6611        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6612        '''
6613         Tags is a map of key, value pairs.
6614        '''
6615        self.token = token if token is not None else ''
6616
6617    def __repr__(self):
6618        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
6619            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6620            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6621            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6622            'healthy: ' + repr(self.healthy) + ' ' +\
6623            'hostname: ' + repr(self.hostname) + ' ' +\
6624            'id: ' + repr(self.id) + ' ' +\
6625            'name: ' + repr(self.name) + ' ' +\
6626            'port: ' + repr(self.port) + ' ' +\
6627            'port_override: ' + repr(self.port_override) + ' ' +\
6628            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6629            'tags: ' + repr(self.tags) + ' ' +\
6630            'token: ' + repr(self.token) + ' ' +\
6631            '>'
6632
6633    def to_dict(self):
6634        return {
6635            'bind_interface': self.bind_interface,
6636            'egress_filter': self.egress_filter,
6637            'healthcheck_namespace': self.healthcheck_namespace,
6638            'healthy': self.healthy,
6639            'hostname': self.hostname,
6640            'id': self.id,
6641            'name': self.name,
6642            'port': self.port,
6643            'port_override': self.port_override,
6644            'secret_store_id': self.secret_store_id,
6645            'tags': self.tags,
6646            'token': self.token,
6647        }
6648
6649    @classmethod
6650    def from_dict(cls, d):
6651        return cls(
6652            bind_interface=d.get('bind_interface'),
6653            egress_filter=d.get('egress_filter'),
6654            healthcheck_namespace=d.get('healthcheck_namespace'),
6655            healthy=d.get('healthy'),
6656            hostname=d.get('hostname'),
6657            id=d.get('id'),
6658            name=d.get('name'),
6659            port=d.get('port'),
6660            port_override=d.get('port_override'),
6661            secret_store_id=d.get('secret_store_id'),
6662            tags=d.get('tags'),
6663            token=d.get('token'),
6664        )
KubernetesServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None, token=None)
6565    def __init__(
6566        self,
6567        bind_interface=None,
6568        egress_filter=None,
6569        healthcheck_namespace=None,
6570        healthy=None,
6571        hostname=None,
6572        id=None,
6573        name=None,
6574        port=None,
6575        port_override=None,
6576        secret_store_id=None,
6577        tags=None,
6578        token=None,
6579    ):
6580        self.bind_interface = bind_interface if bind_interface is not None else ''
6581        '''
6582         Bind interface
6583        '''
6584        self.egress_filter = egress_filter if egress_filter is not None else ''
6585        '''
6586         A filter applied to the routing logic to pin datasource to nodes.
6587        '''
6588        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6589        '''
6590         The path used to check the health of your connection.  Defaults to `default`.
6591        '''
6592        self.healthy = healthy if healthy is not None else False
6593        '''
6594         True if the datasource is reachable and the credentials are valid.
6595        '''
6596        self.hostname = hostname if hostname is not None else ''
6597        self.id = id if id is not None else ''
6598        '''
6599         Unique identifier of the Resource.
6600        '''
6601        self.name = name if name is not None else ''
6602        '''
6603         Unique human-readable name of the Resource.
6604        '''
6605        self.port = port if port is not None else 0
6606        self.port_override = port_override if port_override is not None else 0
6607        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6608        '''
6609         ID of the secret store containing credentials for this resource, if any.
6610        '''
6611        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6612        '''
6613         Tags is a map of key, value pairs.
6614        '''
6615        self.token = token if token is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6633    def to_dict(self):
6634        return {
6635            'bind_interface': self.bind_interface,
6636            'egress_filter': self.egress_filter,
6637            'healthcheck_namespace': self.healthcheck_namespace,
6638            'healthy': self.healthy,
6639            'hostname': self.hostname,
6640            'id': self.id,
6641            'name': self.name,
6642            'port': self.port,
6643            'port_override': self.port_override,
6644            'secret_store_id': self.secret_store_id,
6645            'tags': self.tags,
6646            'token': self.token,
6647        }
@classmethod
def from_dict(cls, d)
6649    @classmethod
6650    def from_dict(cls, d):
6651        return cls(
6652            bind_interface=d.get('bind_interface'),
6653            egress_filter=d.get('egress_filter'),
6654            healthcheck_namespace=d.get('healthcheck_namespace'),
6655            healthy=d.get('healthy'),
6656            hostname=d.get('hostname'),
6657            id=d.get('id'),
6658            name=d.get('name'),
6659            port=d.get('port'),
6660            port_override=d.get('port_override'),
6661            secret_store_id=d.get('secret_store_id'),
6662            tags=d.get('tags'),
6663            token=d.get('token'),
6664        )
class KubernetesUserImpersonation:
6667class KubernetesUserImpersonation:
6668    __slots__ = [
6669        'bind_interface',
6670        'certificate_authority',
6671        'client_certificate',
6672        'client_key',
6673        'egress_filter',
6674        'healthcheck_namespace',
6675        'healthy',
6676        'hostname',
6677        'id',
6678        'name',
6679        'port',
6680        'port_override',
6681        'secret_store_id',
6682        'tags',
6683    ]
6684
6685    def __init__(
6686        self,
6687        bind_interface=None,
6688        certificate_authority=None,
6689        client_certificate=None,
6690        client_key=None,
6691        egress_filter=None,
6692        healthcheck_namespace=None,
6693        healthy=None,
6694        hostname=None,
6695        id=None,
6696        name=None,
6697        port=None,
6698        port_override=None,
6699        secret_store_id=None,
6700        tags=None,
6701    ):
6702        self.bind_interface = bind_interface if bind_interface is not None else ''
6703        '''
6704         Bind interface
6705        '''
6706        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6707        self.client_certificate = client_certificate if client_certificate is not None else ''
6708        self.client_key = client_key if client_key is not None else ''
6709        self.egress_filter = egress_filter if egress_filter is not None else ''
6710        '''
6711         A filter applied to the routing logic to pin datasource to nodes.
6712        '''
6713        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6714        '''
6715         The path used to check the health of your connection.  Defaults to `default`.
6716        '''
6717        self.healthy = healthy if healthy is not None else False
6718        '''
6719         True if the datasource is reachable and the credentials are valid.
6720        '''
6721        self.hostname = hostname if hostname is not None else ''
6722        self.id = id if id is not None else ''
6723        '''
6724         Unique identifier of the Resource.
6725        '''
6726        self.name = name if name is not None else ''
6727        '''
6728         Unique human-readable name of the Resource.
6729        '''
6730        self.port = port if port is not None else 0
6731        self.port_override = port_override if port_override is not None else 0
6732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6733        '''
6734         ID of the secret store containing credentials for this resource, if any.
6735        '''
6736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6737        '''
6738         Tags is a map of key, value pairs.
6739        '''
6740
6741    def __repr__(self):
6742        return '<sdm.KubernetesUserImpersonation ' + \
6743            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6744            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6745            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6746            'client_key: ' + repr(self.client_key) + ' ' +\
6747            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6748            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6749            'healthy: ' + repr(self.healthy) + ' ' +\
6750            'hostname: ' + repr(self.hostname) + ' ' +\
6751            'id: ' + repr(self.id) + ' ' +\
6752            'name: ' + repr(self.name) + ' ' +\
6753            'port: ' + repr(self.port) + ' ' +\
6754            'port_override: ' + repr(self.port_override) + ' ' +\
6755            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6756            'tags: ' + repr(self.tags) + ' ' +\
6757            '>'
6758
6759    def to_dict(self):
6760        return {
6761            'bind_interface': self.bind_interface,
6762            'certificate_authority': self.certificate_authority,
6763            'client_certificate': self.client_certificate,
6764            'client_key': self.client_key,
6765            'egress_filter': self.egress_filter,
6766            'healthcheck_namespace': self.healthcheck_namespace,
6767            'healthy': self.healthy,
6768            'hostname': self.hostname,
6769            'id': self.id,
6770            'name': self.name,
6771            'port': self.port,
6772            'port_override': self.port_override,
6773            'secret_store_id': self.secret_store_id,
6774            'tags': self.tags,
6775        }
6776
6777    @classmethod
6778    def from_dict(cls, d):
6779        return cls(
6780            bind_interface=d.get('bind_interface'),
6781            certificate_authority=d.get('certificate_authority'),
6782            client_certificate=d.get('client_certificate'),
6783            client_key=d.get('client_key'),
6784            egress_filter=d.get('egress_filter'),
6785            healthcheck_namespace=d.get('healthcheck_namespace'),
6786            healthy=d.get('healthy'),
6787            hostname=d.get('hostname'),
6788            id=d.get('id'),
6789            name=d.get('name'),
6790            port=d.get('port'),
6791            port_override=d.get('port_override'),
6792            secret_store_id=d.get('secret_store_id'),
6793            tags=d.get('tags'),
6794        )
KubernetesUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
6685    def __init__(
6686        self,
6687        bind_interface=None,
6688        certificate_authority=None,
6689        client_certificate=None,
6690        client_key=None,
6691        egress_filter=None,
6692        healthcheck_namespace=None,
6693        healthy=None,
6694        hostname=None,
6695        id=None,
6696        name=None,
6697        port=None,
6698        port_override=None,
6699        secret_store_id=None,
6700        tags=None,
6701    ):
6702        self.bind_interface = bind_interface if bind_interface is not None else ''
6703        '''
6704         Bind interface
6705        '''
6706        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6707        self.client_certificate = client_certificate if client_certificate is not None else ''
6708        self.client_key = client_key if client_key is not None else ''
6709        self.egress_filter = egress_filter if egress_filter is not None else ''
6710        '''
6711         A filter applied to the routing logic to pin datasource to nodes.
6712        '''
6713        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6714        '''
6715         The path used to check the health of your connection.  Defaults to `default`.
6716        '''
6717        self.healthy = healthy if healthy is not None else False
6718        '''
6719         True if the datasource is reachable and the credentials are valid.
6720        '''
6721        self.hostname = hostname if hostname is not None else ''
6722        self.id = id if id is not None else ''
6723        '''
6724         Unique identifier of the Resource.
6725        '''
6726        self.name = name if name is not None else ''
6727        '''
6728         Unique human-readable name of the Resource.
6729        '''
6730        self.port = port if port is not None else 0
6731        self.port_override = port_override if port_override is not None else 0
6732        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6733        '''
6734         ID of the secret store containing credentials for this resource, if any.
6735        '''
6736        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6737        '''
6738         Tags is a map of key, value pairs.
6739        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6759    def to_dict(self):
6760        return {
6761            'bind_interface': self.bind_interface,
6762            'certificate_authority': self.certificate_authority,
6763            'client_certificate': self.client_certificate,
6764            'client_key': self.client_key,
6765            'egress_filter': self.egress_filter,
6766            'healthcheck_namespace': self.healthcheck_namespace,
6767            'healthy': self.healthy,
6768            'hostname': self.hostname,
6769            'id': self.id,
6770            'name': self.name,
6771            'port': self.port,
6772            'port_override': self.port_override,
6773            'secret_store_id': self.secret_store_id,
6774            'tags': self.tags,
6775        }
@classmethod
def from_dict(cls, d)
6777    @classmethod
6778    def from_dict(cls, d):
6779        return cls(
6780            bind_interface=d.get('bind_interface'),
6781            certificate_authority=d.get('certificate_authority'),
6782            client_certificate=d.get('client_certificate'),
6783            client_key=d.get('client_key'),
6784            egress_filter=d.get('egress_filter'),
6785            healthcheck_namespace=d.get('healthcheck_namespace'),
6786            healthy=d.get('healthy'),
6787            hostname=d.get('hostname'),
6788            id=d.get('id'),
6789            name=d.get('name'),
6790            port=d.get('port'),
6791            port_override=d.get('port_override'),
6792            secret_store_id=d.get('secret_store_id'),
6793            tags=d.get('tags'),
6794        )
class MTLSMysql:
6797class MTLSMysql:
6798    '''
6799    MTLSMysql is currently unstable, and its API may change, or it may be removed,
6800    without a major version bump.
6801    '''
6802    __slots__ = [
6803        'bind_interface',
6804        'certificate_authority',
6805        'client_certificate',
6806        'client_key',
6807        'database',
6808        'egress_filter',
6809        'healthy',
6810        'hostname',
6811        'id',
6812        'name',
6813        'password',
6814        'port',
6815        'port_override',
6816        'secret_store_id',
6817        'server_name',
6818        'tags',
6819        'username',
6820    ]
6821
6822    def __init__(
6823        self,
6824        bind_interface=None,
6825        certificate_authority=None,
6826        client_certificate=None,
6827        client_key=None,
6828        database=None,
6829        egress_filter=None,
6830        healthy=None,
6831        hostname=None,
6832        id=None,
6833        name=None,
6834        password=None,
6835        port=None,
6836        port_override=None,
6837        secret_store_id=None,
6838        server_name=None,
6839        tags=None,
6840        username=None,
6841    ):
6842        self.bind_interface = bind_interface if bind_interface is not None else ''
6843        '''
6844         Bind interface
6845        '''
6846        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6847        self.client_certificate = client_certificate if client_certificate is not None else ''
6848        self.client_key = client_key if client_key is not None else ''
6849        self.database = database if database is not None else ''
6850        self.egress_filter = egress_filter if egress_filter is not None else ''
6851        '''
6852         A filter applied to the routing logic to pin datasource to nodes.
6853        '''
6854        self.healthy = healthy if healthy is not None else False
6855        '''
6856         True if the datasource is reachable and the credentials are valid.
6857        '''
6858        self.hostname = hostname if hostname is not None else ''
6859        self.id = id if id is not None else ''
6860        '''
6861         Unique identifier of the Resource.
6862        '''
6863        self.name = name if name is not None else ''
6864        '''
6865         Unique human-readable name of the Resource.
6866        '''
6867        self.password = password if password is not None else ''
6868        self.port = port if port is not None else 0
6869        self.port_override = port_override if port_override is not None else 0
6870        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6871        '''
6872         ID of the secret store containing credentials for this resource, if any.
6873        '''
6874        self.server_name = server_name if server_name is not None else ''
6875        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6876        '''
6877         Tags is a map of key, value pairs.
6878        '''
6879        self.username = username if username is not None else ''
6880
6881    def __repr__(self):
6882        return '<sdm.MTLSMysql ' + \
6883            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6884            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6885            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6886            'client_key: ' + repr(self.client_key) + ' ' +\
6887            'database: ' + repr(self.database) + ' ' +\
6888            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6889            'healthy: ' + repr(self.healthy) + ' ' +\
6890            'hostname: ' + repr(self.hostname) + ' ' +\
6891            'id: ' + repr(self.id) + ' ' +\
6892            'name: ' + repr(self.name) + ' ' +\
6893            'password: ' + repr(self.password) + ' ' +\
6894            'port: ' + repr(self.port) + ' ' +\
6895            'port_override: ' + repr(self.port_override) + ' ' +\
6896            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6897            'server_name: ' + repr(self.server_name) + ' ' +\
6898            'tags: ' + repr(self.tags) + ' ' +\
6899            'username: ' + repr(self.username) + ' ' +\
6900            '>'
6901
6902    def to_dict(self):
6903        return {
6904            'bind_interface': self.bind_interface,
6905            'certificate_authority': self.certificate_authority,
6906            'client_certificate': self.client_certificate,
6907            'client_key': self.client_key,
6908            'database': self.database,
6909            'egress_filter': self.egress_filter,
6910            'healthy': self.healthy,
6911            'hostname': self.hostname,
6912            'id': self.id,
6913            'name': self.name,
6914            'password': self.password,
6915            'port': self.port,
6916            'port_override': self.port_override,
6917            'secret_store_id': self.secret_store_id,
6918            'server_name': self.server_name,
6919            'tags': self.tags,
6920            'username': self.username,
6921        }
6922
6923    @classmethod
6924    def from_dict(cls, d):
6925        return cls(
6926            bind_interface=d.get('bind_interface'),
6927            certificate_authority=d.get('certificate_authority'),
6928            client_certificate=d.get('client_certificate'),
6929            client_key=d.get('client_key'),
6930            database=d.get('database'),
6931            egress_filter=d.get('egress_filter'),
6932            healthy=d.get('healthy'),
6933            hostname=d.get('hostname'),
6934            id=d.get('id'),
6935            name=d.get('name'),
6936            password=d.get('password'),
6937            port=d.get('port'),
6938            port_override=d.get('port_override'),
6939            secret_store_id=d.get('secret_store_id'),
6940            server_name=d.get('server_name'),
6941            tags=d.get('tags'),
6942            username=d.get('username'),
6943        )

MTLSMysql is currently unstable, and its API may change, or it may be removed, without a major version bump.

MTLSMysql( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6822    def __init__(
6823        self,
6824        bind_interface=None,
6825        certificate_authority=None,
6826        client_certificate=None,
6827        client_key=None,
6828        database=None,
6829        egress_filter=None,
6830        healthy=None,
6831        hostname=None,
6832        id=None,
6833        name=None,
6834        password=None,
6835        port=None,
6836        port_override=None,
6837        secret_store_id=None,
6838        server_name=None,
6839        tags=None,
6840        username=None,
6841    ):
6842        self.bind_interface = bind_interface if bind_interface is not None else ''
6843        '''
6844         Bind interface
6845        '''
6846        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6847        self.client_certificate = client_certificate if client_certificate is not None else ''
6848        self.client_key = client_key if client_key is not None else ''
6849        self.database = database if database is not None else ''
6850        self.egress_filter = egress_filter if egress_filter is not None else ''
6851        '''
6852         A filter applied to the routing logic to pin datasource to nodes.
6853        '''
6854        self.healthy = healthy if healthy is not None else False
6855        '''
6856         True if the datasource is reachable and the credentials are valid.
6857        '''
6858        self.hostname = hostname if hostname is not None else ''
6859        self.id = id if id is not None else ''
6860        '''
6861         Unique identifier of the Resource.
6862        '''
6863        self.name = name if name is not None else ''
6864        '''
6865         Unique human-readable name of the Resource.
6866        '''
6867        self.password = password if password is not None else ''
6868        self.port = port if port is not None else 0
6869        self.port_override = port_override if port_override is not None else 0
6870        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6871        '''
6872         ID of the secret store containing credentials for this resource, if any.
6873        '''
6874        self.server_name = server_name if server_name is not None else ''
6875        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6876        '''
6877         Tags is a map of key, value pairs.
6878        '''
6879        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6902    def to_dict(self):
6903        return {
6904            'bind_interface': self.bind_interface,
6905            'certificate_authority': self.certificate_authority,
6906            'client_certificate': self.client_certificate,
6907            'client_key': self.client_key,
6908            'database': self.database,
6909            'egress_filter': self.egress_filter,
6910            'healthy': self.healthy,
6911            'hostname': self.hostname,
6912            'id': self.id,
6913            'name': self.name,
6914            'password': self.password,
6915            'port': self.port,
6916            'port_override': self.port_override,
6917            'secret_store_id': self.secret_store_id,
6918            'server_name': self.server_name,
6919            'tags': self.tags,
6920            'username': self.username,
6921        }
@classmethod
def from_dict(cls, d)
6923    @classmethod
6924    def from_dict(cls, d):
6925        return cls(
6926            bind_interface=d.get('bind_interface'),
6927            certificate_authority=d.get('certificate_authority'),
6928            client_certificate=d.get('client_certificate'),
6929            client_key=d.get('client_key'),
6930            database=d.get('database'),
6931            egress_filter=d.get('egress_filter'),
6932            healthy=d.get('healthy'),
6933            hostname=d.get('hostname'),
6934            id=d.get('id'),
6935            name=d.get('name'),
6936            password=d.get('password'),
6937            port=d.get('port'),
6938            port_override=d.get('port_override'),
6939            secret_store_id=d.get('secret_store_id'),
6940            server_name=d.get('server_name'),
6941            tags=d.get('tags'),
6942            username=d.get('username'),
6943        )
class MTLSPostgres:
6946class MTLSPostgres:
6947    __slots__ = [
6948        'bind_interface',
6949        'certificate_authority',
6950        'client_certificate',
6951        'client_key',
6952        'database',
6953        'egress_filter',
6954        'healthy',
6955        'hostname',
6956        'id',
6957        'name',
6958        'override_database',
6959        'password',
6960        'port',
6961        'port_override',
6962        'secret_store_id',
6963        'server_name',
6964        'tags',
6965        'username',
6966    ]
6967
6968    def __init__(
6969        self,
6970        bind_interface=None,
6971        certificate_authority=None,
6972        client_certificate=None,
6973        client_key=None,
6974        database=None,
6975        egress_filter=None,
6976        healthy=None,
6977        hostname=None,
6978        id=None,
6979        name=None,
6980        override_database=None,
6981        password=None,
6982        port=None,
6983        port_override=None,
6984        secret_store_id=None,
6985        server_name=None,
6986        tags=None,
6987        username=None,
6988    ):
6989        self.bind_interface = bind_interface if bind_interface is not None else ''
6990        '''
6991         Bind interface
6992        '''
6993        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6994        self.client_certificate = client_certificate if client_certificate is not None else ''
6995        self.client_key = client_key if client_key is not None else ''
6996        self.database = database if database is not None else ''
6997        self.egress_filter = egress_filter if egress_filter is not None else ''
6998        '''
6999         A filter applied to the routing logic to pin datasource to nodes.
7000        '''
7001        self.healthy = healthy if healthy is not None else False
7002        '''
7003         True if the datasource is reachable and the credentials are valid.
7004        '''
7005        self.hostname = hostname if hostname is not None else ''
7006        self.id = id if id is not None else ''
7007        '''
7008         Unique identifier of the Resource.
7009        '''
7010        self.name = name if name is not None else ''
7011        '''
7012         Unique human-readable name of the Resource.
7013        '''
7014        self.override_database = override_database if override_database is not None else False
7015        self.password = password if password is not None else ''
7016        self.port = port if port is not None else 0
7017        self.port_override = port_override if port_override is not None else 0
7018        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7019        '''
7020         ID of the secret store containing credentials for this resource, if any.
7021        '''
7022        self.server_name = server_name if server_name is not None else ''
7023        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7024        '''
7025         Tags is a map of key, value pairs.
7026        '''
7027        self.username = username if username is not None else ''
7028
7029    def __repr__(self):
7030        return '<sdm.MTLSPostgres ' + \
7031            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7032            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
7033            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
7034            'client_key: ' + repr(self.client_key) + ' ' +\
7035            'database: ' + repr(self.database) + ' ' +\
7036            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7037            'healthy: ' + repr(self.healthy) + ' ' +\
7038            'hostname: ' + repr(self.hostname) + ' ' +\
7039            'id: ' + repr(self.id) + ' ' +\
7040            'name: ' + repr(self.name) + ' ' +\
7041            'override_database: ' + repr(self.override_database) + ' ' +\
7042            'password: ' + repr(self.password) + ' ' +\
7043            'port: ' + repr(self.port) + ' ' +\
7044            'port_override: ' + repr(self.port_override) + ' ' +\
7045            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7046            'server_name: ' + repr(self.server_name) + ' ' +\
7047            'tags: ' + repr(self.tags) + ' ' +\
7048            'username: ' + repr(self.username) + ' ' +\
7049            '>'
7050
7051    def to_dict(self):
7052        return {
7053            'bind_interface': self.bind_interface,
7054            'certificate_authority': self.certificate_authority,
7055            'client_certificate': self.client_certificate,
7056            'client_key': self.client_key,
7057            'database': self.database,
7058            'egress_filter': self.egress_filter,
7059            'healthy': self.healthy,
7060            'hostname': self.hostname,
7061            'id': self.id,
7062            'name': self.name,
7063            'override_database': self.override_database,
7064            'password': self.password,
7065            'port': self.port,
7066            'port_override': self.port_override,
7067            'secret_store_id': self.secret_store_id,
7068            'server_name': self.server_name,
7069            'tags': self.tags,
7070            'username': self.username,
7071        }
7072
7073    @classmethod
7074    def from_dict(cls, d):
7075        return cls(
7076            bind_interface=d.get('bind_interface'),
7077            certificate_authority=d.get('certificate_authority'),
7078            client_certificate=d.get('client_certificate'),
7079            client_key=d.get('client_key'),
7080            database=d.get('database'),
7081            egress_filter=d.get('egress_filter'),
7082            healthy=d.get('healthy'),
7083            hostname=d.get('hostname'),
7084            id=d.get('id'),
7085            name=d.get('name'),
7086            override_database=d.get('override_database'),
7087            password=d.get('password'),
7088            port=d.get('port'),
7089            port_override=d.get('port_override'),
7090            secret_store_id=d.get('secret_store_id'),
7091            server_name=d.get('server_name'),
7092            tags=d.get('tags'),
7093            username=d.get('username'),
7094        )
MTLSPostgres( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6968    def __init__(
6969        self,
6970        bind_interface=None,
6971        certificate_authority=None,
6972        client_certificate=None,
6973        client_key=None,
6974        database=None,
6975        egress_filter=None,
6976        healthy=None,
6977        hostname=None,
6978        id=None,
6979        name=None,
6980        override_database=None,
6981        password=None,
6982        port=None,
6983        port_override=None,
6984        secret_store_id=None,
6985        server_name=None,
6986        tags=None,
6987        username=None,
6988    ):
6989        self.bind_interface = bind_interface if bind_interface is not None else ''
6990        '''
6991         Bind interface
6992        '''
6993        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6994        self.client_certificate = client_certificate if client_certificate is not None else ''
6995        self.client_key = client_key if client_key is not None else ''
6996        self.database = database if database is not None else ''
6997        self.egress_filter = egress_filter if egress_filter is not None else ''
6998        '''
6999         A filter applied to the routing logic to pin datasource to nodes.
7000        '''
7001        self.healthy = healthy if healthy is not None else False
7002        '''
7003         True if the datasource is reachable and the credentials are valid.
7004        '''
7005        self.hostname = hostname if hostname is not None else ''
7006        self.id = id if id is not None else ''
7007        '''
7008         Unique identifier of the Resource.
7009        '''
7010        self.name = name if name is not None else ''
7011        '''
7012         Unique human-readable name of the Resource.
7013        '''
7014        self.override_database = override_database if override_database is not None else False
7015        self.password = password if password is not None else ''
7016        self.port = port if port is not None else 0
7017        self.port_override = port_override if port_override is not None else 0
7018        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7019        '''
7020         ID of the secret store containing credentials for this resource, if any.
7021        '''
7022        self.server_name = server_name if server_name is not None else ''
7023        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7024        '''
7025         Tags is a map of key, value pairs.
7026        '''
7027        self.username = username if username is not None else ''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7051    def to_dict(self):
7052        return {
7053            'bind_interface': self.bind_interface,
7054            'certificate_authority': self.certificate_authority,
7055            'client_certificate': self.client_certificate,
7056            'client_key': self.client_key,
7057            'database': self.database,
7058            'egress_filter': self.egress_filter,
7059            'healthy': self.healthy,
7060            'hostname': self.hostname,
7061            'id': self.id,
7062            'name': self.name,
7063            'override_database': self.override_database,
7064            'password': self.password,
7065            'port': self.port,
7066            'port_override': self.port_override,
7067            'secret_store_id': self.secret_store_id,
7068            'server_name': self.server_name,
7069            'tags': self.tags,
7070            'username': self.username,
7071        }
@classmethod
def from_dict(cls, d)
7073    @classmethod
7074    def from_dict(cls, d):
7075        return cls(
7076            bind_interface=d.get('bind_interface'),
7077            certificate_authority=d.get('certificate_authority'),
7078            client_certificate=d.get('client_certificate'),
7079            client_key=d.get('client_key'),
7080            database=d.get('database'),
7081            egress_filter=d.get('egress_filter'),
7082            healthy=d.get('healthy'),
7083            hostname=d.get('hostname'),
7084            id=d.get('id'),
7085            name=d.get('name'),
7086            override_database=d.get('override_database'),
7087            password=d.get('password'),
7088            port=d.get('port'),
7089            port_override=d.get('port_override'),
7090            secret_store_id=d.get('secret_store_id'),
7091            server_name=d.get('server_name'),
7092            tags=d.get('tags'),
7093            username=d.get('username'),
7094        )
class Maria:
7097class Maria:
7098    __slots__ = [
7099        'bind_interface',
7100        'database',
7101        'egress_filter',
7102        'healthy',
7103        'hostname',
7104        'id',
7105        'name',
7106        'password',
7107        'port',
7108        'port_override',
7109        'secret_store_id',
7110        'tags',
7111        'username',
7112    ]
7113
7114    def __init__(
7115        self,
7116        bind_interface=None,
7117        database=None,
7118        egress_filter=None,
7119        healthy=None,
7120        hostname=None,
7121        id=None,
7122        name=None,
7123        password=None,
7124        port=None,
7125        port_override=None,
7126        secret_store_id=None,
7127        tags=None,
7128        username=None,
7129    ):
7130        self.bind_interface = bind_interface if bind_interface is not None else ''
7131        '''
7132         Bind interface
7133        '''
7134        self.database = database if database is not None else ''
7135        self.egress_filter = egress_filter if egress_filter is not None else ''
7136        '''
7137         A filter applied to the routing logic to pin datasource to nodes.
7138        '''
7139        self.healthy = healthy if healthy is not None else False
7140        '''
7141         True if the datasource is reachable and the credentials are valid.
7142        '''
7143        self.hostname = hostname if hostname is not None else ''
7144        self.id = id if id is not None else ''
7145        '''
7146         Unique identifier of the Resource.
7147        '''
7148        self.name = name if name is not None else ''
7149        '''
7150         Unique human-readable name of the Resource.
7151        '''
7152        self.password = password if password is not None else ''
7153        self.port = port if port is not None else 0
7154        self.port_override = port_override if port_override is not None else 0
7155        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7156        '''
7157         ID of the secret store containing credentials for this resource, if any.
7158        '''
7159        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7160        '''
7161         Tags is a map of key, value pairs.
7162        '''
7163        self.username = username if username is not None else ''
7164
7165    def __repr__(self):
7166        return '<sdm.Maria ' + \
7167            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7168            'database: ' + repr(self.database) + ' ' +\
7169            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7170            'healthy: ' + repr(self.healthy) + ' ' +\
7171            'hostname: ' + repr(self.hostname) + ' ' +\
7172            'id: ' + repr(self.id) + ' ' +\
7173            'name: ' + repr(self.name) + ' ' +\
7174            'password: ' + repr(self.password) + ' ' +\
7175            'port: ' + repr(self.port) + ' ' +\
7176            'port_override: ' + repr(self.port_override) + ' ' +\
7177            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7178            'tags: ' + repr(self.tags) + ' ' +\
7179            'username: ' + repr(self.username) + ' ' +\
7180            '>'
7181
7182    def to_dict(self):
7183        return {
7184            'bind_interface': self.bind_interface,
7185            'database': self.database,
7186            'egress_filter': self.egress_filter,
7187            'healthy': self.healthy,
7188            'hostname': self.hostname,
7189            'id': self.id,
7190            'name': self.name,
7191            'password': self.password,
7192            'port': self.port,
7193            'port_override': self.port_override,
7194            'secret_store_id': self.secret_store_id,
7195            'tags': self.tags,
7196            'username': self.username,
7197        }
7198
7199    @classmethod
7200    def from_dict(cls, d):
7201        return cls(
7202            bind_interface=d.get('bind_interface'),
7203            database=d.get('database'),
7204            egress_filter=d.get('egress_filter'),
7205            healthy=d.get('healthy'),
7206            hostname=d.get('hostname'),
7207            id=d.get('id'),
7208            name=d.get('name'),
7209            password=d.get('password'),
7210            port=d.get('port'),
7211            port_override=d.get('port_override'),
7212            secret_store_id=d.get('secret_store_id'),
7213            tags=d.get('tags'),
7214            username=d.get('username'),
7215        )
Maria( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7114    def __init__(
7115        self,
7116        bind_interface=None,
7117        database=None,
7118        egress_filter=None,
7119        healthy=None,
7120        hostname=None,
7121        id=None,
7122        name=None,
7123        password=None,
7124        port=None,
7125        port_override=None,
7126        secret_store_id=None,
7127        tags=None,
7128        username=None,
7129    ):
7130        self.bind_interface = bind_interface if bind_interface is not None else ''
7131        '''
7132         Bind interface
7133        '''
7134        self.database = database if database is not None else ''
7135        self.egress_filter = egress_filter if egress_filter is not None else ''
7136        '''
7137         A filter applied to the routing logic to pin datasource to nodes.
7138        '''
7139        self.healthy = healthy if healthy is not None else False
7140        '''
7141         True if the datasource is reachable and the credentials are valid.
7142        '''
7143        self.hostname = hostname if hostname is not None else ''
7144        self.id = id if id is not None else ''
7145        '''
7146         Unique identifier of the Resource.
7147        '''
7148        self.name = name if name is not None else ''
7149        '''
7150         Unique human-readable name of the Resource.
7151        '''
7152        self.password = password if password is not None else ''
7153        self.port = port if port is not None else 0
7154        self.port_override = port_override if port_override is not None else 0
7155        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7156        '''
7157         ID of the secret store containing credentials for this resource, if any.
7158        '''
7159        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7160        '''
7161         Tags is a map of key, value pairs.
7162        '''
7163        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7182    def to_dict(self):
7183        return {
7184            'bind_interface': self.bind_interface,
7185            'database': self.database,
7186            'egress_filter': self.egress_filter,
7187            'healthy': self.healthy,
7188            'hostname': self.hostname,
7189            'id': self.id,
7190            'name': self.name,
7191            'password': self.password,
7192            'port': self.port,
7193            'port_override': self.port_override,
7194            'secret_store_id': self.secret_store_id,
7195            'tags': self.tags,
7196            'username': self.username,
7197        }
@classmethod
def from_dict(cls, d)
7199    @classmethod
7200    def from_dict(cls, d):
7201        return cls(
7202            bind_interface=d.get('bind_interface'),
7203            database=d.get('database'),
7204            egress_filter=d.get('egress_filter'),
7205            healthy=d.get('healthy'),
7206            hostname=d.get('hostname'),
7207            id=d.get('id'),
7208            name=d.get('name'),
7209            password=d.get('password'),
7210            port=d.get('port'),
7211            port_override=d.get('port_override'),
7212            secret_store_id=d.get('secret_store_id'),
7213            tags=d.get('tags'),
7214            username=d.get('username'),
7215        )
class Memcached:
7218class Memcached:
7219    __slots__ = [
7220        'bind_interface',
7221        'egress_filter',
7222        'healthy',
7223        'hostname',
7224        'id',
7225        'name',
7226        'port',
7227        'port_override',
7228        'secret_store_id',
7229        'tags',
7230    ]
7231
7232    def __init__(
7233        self,
7234        bind_interface=None,
7235        egress_filter=None,
7236        healthy=None,
7237        hostname=None,
7238        id=None,
7239        name=None,
7240        port=None,
7241        port_override=None,
7242        secret_store_id=None,
7243        tags=None,
7244    ):
7245        self.bind_interface = bind_interface if bind_interface is not None else ''
7246        '''
7247         Bind interface
7248        '''
7249        self.egress_filter = egress_filter if egress_filter is not None else ''
7250        '''
7251         A filter applied to the routing logic to pin datasource to nodes.
7252        '''
7253        self.healthy = healthy if healthy is not None else False
7254        '''
7255         True if the datasource is reachable and the credentials are valid.
7256        '''
7257        self.hostname = hostname if hostname is not None else ''
7258        self.id = id if id is not None else ''
7259        '''
7260         Unique identifier of the Resource.
7261        '''
7262        self.name = name if name is not None else ''
7263        '''
7264         Unique human-readable name of the Resource.
7265        '''
7266        self.port = port if port is not None else 0
7267        self.port_override = port_override if port_override is not None else 0
7268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7269        '''
7270         ID of the secret store containing credentials for this resource, if any.
7271        '''
7272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7273        '''
7274         Tags is a map of key, value pairs.
7275        '''
7276
7277    def __repr__(self):
7278        return '<sdm.Memcached ' + \
7279            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7280            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7281            'healthy: ' + repr(self.healthy) + ' ' +\
7282            'hostname: ' + repr(self.hostname) + ' ' +\
7283            'id: ' + repr(self.id) + ' ' +\
7284            'name: ' + repr(self.name) + ' ' +\
7285            'port: ' + repr(self.port) + ' ' +\
7286            'port_override: ' + repr(self.port_override) + ' ' +\
7287            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7288            'tags: ' + repr(self.tags) + ' ' +\
7289            '>'
7290
7291    def to_dict(self):
7292        return {
7293            'bind_interface': self.bind_interface,
7294            'egress_filter': self.egress_filter,
7295            'healthy': self.healthy,
7296            'hostname': self.hostname,
7297            'id': self.id,
7298            'name': self.name,
7299            'port': self.port,
7300            'port_override': self.port_override,
7301            'secret_store_id': self.secret_store_id,
7302            'tags': self.tags,
7303        }
7304
7305    @classmethod
7306    def from_dict(cls, d):
7307        return cls(
7308            bind_interface=d.get('bind_interface'),
7309            egress_filter=d.get('egress_filter'),
7310            healthy=d.get('healthy'),
7311            hostname=d.get('hostname'),
7312            id=d.get('id'),
7313            name=d.get('name'),
7314            port=d.get('port'),
7315            port_override=d.get('port_override'),
7316            secret_store_id=d.get('secret_store_id'),
7317            tags=d.get('tags'),
7318        )
Memcached( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
7232    def __init__(
7233        self,
7234        bind_interface=None,
7235        egress_filter=None,
7236        healthy=None,
7237        hostname=None,
7238        id=None,
7239        name=None,
7240        port=None,
7241        port_override=None,
7242        secret_store_id=None,
7243        tags=None,
7244    ):
7245        self.bind_interface = bind_interface if bind_interface is not None else ''
7246        '''
7247         Bind interface
7248        '''
7249        self.egress_filter = egress_filter if egress_filter is not None else ''
7250        '''
7251         A filter applied to the routing logic to pin datasource to nodes.
7252        '''
7253        self.healthy = healthy if healthy is not None else False
7254        '''
7255         True if the datasource is reachable and the credentials are valid.
7256        '''
7257        self.hostname = hostname if hostname is not None else ''
7258        self.id = id if id is not None else ''
7259        '''
7260         Unique identifier of the Resource.
7261        '''
7262        self.name = name if name is not None else ''
7263        '''
7264         Unique human-readable name of the Resource.
7265        '''
7266        self.port = port if port is not None else 0
7267        self.port_override = port_override if port_override is not None else 0
7268        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7269        '''
7270         ID of the secret store containing credentials for this resource, if any.
7271        '''
7272        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7273        '''
7274         Tags is a map of key, value pairs.
7275        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7291    def to_dict(self):
7292        return {
7293            'bind_interface': self.bind_interface,
7294            'egress_filter': self.egress_filter,
7295            'healthy': self.healthy,
7296            'hostname': self.hostname,
7297            'id': self.id,
7298            'name': self.name,
7299            'port': self.port,
7300            'port_override': self.port_override,
7301            'secret_store_id': self.secret_store_id,
7302            'tags': self.tags,
7303        }
@classmethod
def from_dict(cls, d)
7305    @classmethod
7306    def from_dict(cls, d):
7307        return cls(
7308            bind_interface=d.get('bind_interface'),
7309            egress_filter=d.get('egress_filter'),
7310            healthy=d.get('healthy'),
7311            hostname=d.get('hostname'),
7312            id=d.get('id'),
7313            name=d.get('name'),
7314            port=d.get('port'),
7315            port_override=d.get('port_override'),
7316            secret_store_id=d.get('secret_store_id'),
7317            tags=d.get('tags'),
7318        )
class Memsql:
7321class Memsql:
7322    __slots__ = [
7323        'bind_interface',
7324        'database',
7325        'egress_filter',
7326        'healthy',
7327        'hostname',
7328        'id',
7329        'name',
7330        'password',
7331        'port',
7332        'port_override',
7333        'secret_store_id',
7334        'tags',
7335        'username',
7336    ]
7337
7338    def __init__(
7339        self,
7340        bind_interface=None,
7341        database=None,
7342        egress_filter=None,
7343        healthy=None,
7344        hostname=None,
7345        id=None,
7346        name=None,
7347        password=None,
7348        port=None,
7349        port_override=None,
7350        secret_store_id=None,
7351        tags=None,
7352        username=None,
7353    ):
7354        self.bind_interface = bind_interface if bind_interface is not None else ''
7355        '''
7356         Bind interface
7357        '''
7358        self.database = database if database is not None else ''
7359        self.egress_filter = egress_filter if egress_filter is not None else ''
7360        '''
7361         A filter applied to the routing logic to pin datasource to nodes.
7362        '''
7363        self.healthy = healthy if healthy is not None else False
7364        '''
7365         True if the datasource is reachable and the credentials are valid.
7366        '''
7367        self.hostname = hostname if hostname is not None else ''
7368        self.id = id if id is not None else ''
7369        '''
7370         Unique identifier of the Resource.
7371        '''
7372        self.name = name if name is not None else ''
7373        '''
7374         Unique human-readable name of the Resource.
7375        '''
7376        self.password = password if password is not None else ''
7377        self.port = port if port is not None else 0
7378        self.port_override = port_override if port_override is not None else 0
7379        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7380        '''
7381         ID of the secret store containing credentials for this resource, if any.
7382        '''
7383        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7384        '''
7385         Tags is a map of key, value pairs.
7386        '''
7387        self.username = username if username is not None else ''
7388
7389    def __repr__(self):
7390        return '<sdm.Memsql ' + \
7391            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7392            'database: ' + repr(self.database) + ' ' +\
7393            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7394            'healthy: ' + repr(self.healthy) + ' ' +\
7395            'hostname: ' + repr(self.hostname) + ' ' +\
7396            'id: ' + repr(self.id) + ' ' +\
7397            'name: ' + repr(self.name) + ' ' +\
7398            'password: ' + repr(self.password) + ' ' +\
7399            'port: ' + repr(self.port) + ' ' +\
7400            'port_override: ' + repr(self.port_override) + ' ' +\
7401            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7402            'tags: ' + repr(self.tags) + ' ' +\
7403            'username: ' + repr(self.username) + ' ' +\
7404            '>'
7405
7406    def to_dict(self):
7407        return {
7408            'bind_interface': self.bind_interface,
7409            'database': self.database,
7410            'egress_filter': self.egress_filter,
7411            'healthy': self.healthy,
7412            'hostname': self.hostname,
7413            'id': self.id,
7414            'name': self.name,
7415            'password': self.password,
7416            'port': self.port,
7417            'port_override': self.port_override,
7418            'secret_store_id': self.secret_store_id,
7419            'tags': self.tags,
7420            'username': self.username,
7421        }
7422
7423    @classmethod
7424    def from_dict(cls, d):
7425        return cls(
7426            bind_interface=d.get('bind_interface'),
7427            database=d.get('database'),
7428            egress_filter=d.get('egress_filter'),
7429            healthy=d.get('healthy'),
7430            hostname=d.get('hostname'),
7431            id=d.get('id'),
7432            name=d.get('name'),
7433            password=d.get('password'),
7434            port=d.get('port'),
7435            port_override=d.get('port_override'),
7436            secret_store_id=d.get('secret_store_id'),
7437            tags=d.get('tags'),
7438            username=d.get('username'),
7439        )
Memsql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7338    def __init__(
7339        self,
7340        bind_interface=None,
7341        database=None,
7342        egress_filter=None,
7343        healthy=None,
7344        hostname=None,
7345        id=None,
7346        name=None,
7347        password=None,
7348        port=None,
7349        port_override=None,
7350        secret_store_id=None,
7351        tags=None,
7352        username=None,
7353    ):
7354        self.bind_interface = bind_interface if bind_interface is not None else ''
7355        '''
7356         Bind interface
7357        '''
7358        self.database = database if database is not None else ''
7359        self.egress_filter = egress_filter if egress_filter is not None else ''
7360        '''
7361         A filter applied to the routing logic to pin datasource to nodes.
7362        '''
7363        self.healthy = healthy if healthy is not None else False
7364        '''
7365         True if the datasource is reachable and the credentials are valid.
7366        '''
7367        self.hostname = hostname if hostname is not None else ''
7368        self.id = id if id is not None else ''
7369        '''
7370         Unique identifier of the Resource.
7371        '''
7372        self.name = name if name is not None else ''
7373        '''
7374         Unique human-readable name of the Resource.
7375        '''
7376        self.password = password if password is not None else ''
7377        self.port = port if port is not None else 0
7378        self.port_override = port_override if port_override is not None else 0
7379        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7380        '''
7381         ID of the secret store containing credentials for this resource, if any.
7382        '''
7383        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7384        '''
7385         Tags is a map of key, value pairs.
7386        '''
7387        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7406    def to_dict(self):
7407        return {
7408            'bind_interface': self.bind_interface,
7409            'database': self.database,
7410            'egress_filter': self.egress_filter,
7411            'healthy': self.healthy,
7412            'hostname': self.hostname,
7413            'id': self.id,
7414            'name': self.name,
7415            'password': self.password,
7416            'port': self.port,
7417            'port_override': self.port_override,
7418            'secret_store_id': self.secret_store_id,
7419            'tags': self.tags,
7420            'username': self.username,
7421        }
@classmethod
def from_dict(cls, d)
7423    @classmethod
7424    def from_dict(cls, d):
7425        return cls(
7426            bind_interface=d.get('bind_interface'),
7427            database=d.get('database'),
7428            egress_filter=d.get('egress_filter'),
7429            healthy=d.get('healthy'),
7430            hostname=d.get('hostname'),
7431            id=d.get('id'),
7432            name=d.get('name'),
7433            password=d.get('password'),
7434            port=d.get('port'),
7435            port_override=d.get('port_override'),
7436            secret_store_id=d.get('secret_store_id'),
7437            tags=d.get('tags'),
7438            username=d.get('username'),
7439        )
class MongoHost:
7442class MongoHost:
7443    '''
7444    MongoHost is currently unstable, and its API may change, or it may be removed,
7445    without a major version bump.
7446    '''
7447    __slots__ = [
7448        'auth_database',
7449        'bind_interface',
7450        'egress_filter',
7451        'healthy',
7452        'hostname',
7453        'id',
7454        'name',
7455        'password',
7456        'port',
7457        'port_override',
7458        'secret_store_id',
7459        'tags',
7460        'tls_required',
7461        'username',
7462    ]
7463
7464    def __init__(
7465        self,
7466        auth_database=None,
7467        bind_interface=None,
7468        egress_filter=None,
7469        healthy=None,
7470        hostname=None,
7471        id=None,
7472        name=None,
7473        password=None,
7474        port=None,
7475        port_override=None,
7476        secret_store_id=None,
7477        tags=None,
7478        tls_required=None,
7479        username=None,
7480    ):
7481        self.auth_database = auth_database if auth_database is not None else ''
7482        self.bind_interface = bind_interface if bind_interface is not None else ''
7483        '''
7484         Bind interface
7485        '''
7486        self.egress_filter = egress_filter if egress_filter is not None else ''
7487        '''
7488         A filter applied to the routing logic to pin datasource to nodes.
7489        '''
7490        self.healthy = healthy if healthy is not None else False
7491        '''
7492         True if the datasource is reachable and the credentials are valid.
7493        '''
7494        self.hostname = hostname if hostname is not None else ''
7495        self.id = id if id is not None else ''
7496        '''
7497         Unique identifier of the Resource.
7498        '''
7499        self.name = name if name is not None else ''
7500        '''
7501         Unique human-readable name of the Resource.
7502        '''
7503        self.password = password if password is not None else ''
7504        self.port = port if port is not None else 0
7505        self.port_override = port_override if port_override is not None else 0
7506        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7507        '''
7508         ID of the secret store containing credentials for this resource, if any.
7509        '''
7510        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7511        '''
7512         Tags is a map of key, value pairs.
7513        '''
7514        self.tls_required = tls_required if tls_required is not None else False
7515        self.username = username if username is not None else ''
7516
7517    def __repr__(self):
7518        return '<sdm.MongoHost ' + \
7519            'auth_database: ' + repr(self.auth_database) + ' ' +\
7520            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7521            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7522            'healthy: ' + repr(self.healthy) + ' ' +\
7523            'hostname: ' + repr(self.hostname) + ' ' +\
7524            'id: ' + repr(self.id) + ' ' +\
7525            'name: ' + repr(self.name) + ' ' +\
7526            'password: ' + repr(self.password) + ' ' +\
7527            'port: ' + repr(self.port) + ' ' +\
7528            'port_override: ' + repr(self.port_override) + ' ' +\
7529            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7530            'tags: ' + repr(self.tags) + ' ' +\
7531            'tls_required: ' + repr(self.tls_required) + ' ' +\
7532            'username: ' + repr(self.username) + ' ' +\
7533            '>'
7534
7535    def to_dict(self):
7536        return {
7537            'auth_database': self.auth_database,
7538            'bind_interface': self.bind_interface,
7539            'egress_filter': self.egress_filter,
7540            'healthy': self.healthy,
7541            'hostname': self.hostname,
7542            'id': self.id,
7543            'name': self.name,
7544            'password': self.password,
7545            'port': self.port,
7546            'port_override': self.port_override,
7547            'secret_store_id': self.secret_store_id,
7548            'tags': self.tags,
7549            'tls_required': self.tls_required,
7550            'username': self.username,
7551        }
7552
7553    @classmethod
7554    def from_dict(cls, d):
7555        return cls(
7556            auth_database=d.get('auth_database'),
7557            bind_interface=d.get('bind_interface'),
7558            egress_filter=d.get('egress_filter'),
7559            healthy=d.get('healthy'),
7560            hostname=d.get('hostname'),
7561            id=d.get('id'),
7562            name=d.get('name'),
7563            password=d.get('password'),
7564            port=d.get('port'),
7565            port_override=d.get('port_override'),
7566            secret_store_id=d.get('secret_store_id'),
7567            tags=d.get('tags'),
7568            tls_required=d.get('tls_required'),
7569            username=d.get('username'),
7570        )

MongoHost is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7464    def __init__(
7465        self,
7466        auth_database=None,
7467        bind_interface=None,
7468        egress_filter=None,
7469        healthy=None,
7470        hostname=None,
7471        id=None,
7472        name=None,
7473        password=None,
7474        port=None,
7475        port_override=None,
7476        secret_store_id=None,
7477        tags=None,
7478        tls_required=None,
7479        username=None,
7480    ):
7481        self.auth_database = auth_database if auth_database is not None else ''
7482        self.bind_interface = bind_interface if bind_interface is not None else ''
7483        '''
7484         Bind interface
7485        '''
7486        self.egress_filter = egress_filter if egress_filter is not None else ''
7487        '''
7488         A filter applied to the routing logic to pin datasource to nodes.
7489        '''
7490        self.healthy = healthy if healthy is not None else False
7491        '''
7492         True if the datasource is reachable and the credentials are valid.
7493        '''
7494        self.hostname = hostname if hostname is not None else ''
7495        self.id = id if id is not None else ''
7496        '''
7497         Unique identifier of the Resource.
7498        '''
7499        self.name = name if name is not None else ''
7500        '''
7501         Unique human-readable name of the Resource.
7502        '''
7503        self.password = password if password is not None else ''
7504        self.port = port if port is not None else 0
7505        self.port_override = port_override if port_override is not None else 0
7506        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7507        '''
7508         ID of the secret store containing credentials for this resource, if any.
7509        '''
7510        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7511        '''
7512         Tags is a map of key, value pairs.
7513        '''
7514        self.tls_required = tls_required if tls_required is not None else False
7515        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7535    def to_dict(self):
7536        return {
7537            'auth_database': self.auth_database,
7538            'bind_interface': self.bind_interface,
7539            'egress_filter': self.egress_filter,
7540            'healthy': self.healthy,
7541            'hostname': self.hostname,
7542            'id': self.id,
7543            'name': self.name,
7544            'password': self.password,
7545            'port': self.port,
7546            'port_override': self.port_override,
7547            'secret_store_id': self.secret_store_id,
7548            'tags': self.tags,
7549            'tls_required': self.tls_required,
7550            'username': self.username,
7551        }
@classmethod
def from_dict(cls, d)
7553    @classmethod
7554    def from_dict(cls, d):
7555        return cls(
7556            auth_database=d.get('auth_database'),
7557            bind_interface=d.get('bind_interface'),
7558            egress_filter=d.get('egress_filter'),
7559            healthy=d.get('healthy'),
7560            hostname=d.get('hostname'),
7561            id=d.get('id'),
7562            name=d.get('name'),
7563            password=d.get('password'),
7564            port=d.get('port'),
7565            port_override=d.get('port_override'),
7566            secret_store_id=d.get('secret_store_id'),
7567            tags=d.get('tags'),
7568            tls_required=d.get('tls_required'),
7569            username=d.get('username'),
7570        )
class MongoLegacyHost:
7573class MongoLegacyHost:
7574    __slots__ = [
7575        'auth_database',
7576        'bind_interface',
7577        'egress_filter',
7578        'healthy',
7579        'hostname',
7580        'id',
7581        'name',
7582        'password',
7583        'port',
7584        'port_override',
7585        'replica_set',
7586        'secret_store_id',
7587        'tags',
7588        'tls_required',
7589        'username',
7590    ]
7591
7592    def __init__(
7593        self,
7594        auth_database=None,
7595        bind_interface=None,
7596        egress_filter=None,
7597        healthy=None,
7598        hostname=None,
7599        id=None,
7600        name=None,
7601        password=None,
7602        port=None,
7603        port_override=None,
7604        replica_set=None,
7605        secret_store_id=None,
7606        tags=None,
7607        tls_required=None,
7608        username=None,
7609    ):
7610        self.auth_database = auth_database if auth_database is not None else ''
7611        self.bind_interface = bind_interface if bind_interface is not None else ''
7612        '''
7613         Bind interface
7614        '''
7615        self.egress_filter = egress_filter if egress_filter is not None else ''
7616        '''
7617         A filter applied to the routing logic to pin datasource to nodes.
7618        '''
7619        self.healthy = healthy if healthy is not None else False
7620        '''
7621         True if the datasource is reachable and the credentials are valid.
7622        '''
7623        self.hostname = hostname if hostname is not None else ''
7624        self.id = id if id is not None else ''
7625        '''
7626         Unique identifier of the Resource.
7627        '''
7628        self.name = name if name is not None else ''
7629        '''
7630         Unique human-readable name of the Resource.
7631        '''
7632        self.password = password if password is not None else ''
7633        self.port = port if port is not None else 0
7634        self.port_override = port_override if port_override is not None else 0
7635        self.replica_set = replica_set if replica_set is not None else ''
7636        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7637        '''
7638         ID of the secret store containing credentials for this resource, if any.
7639        '''
7640        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7641        '''
7642         Tags is a map of key, value pairs.
7643        '''
7644        self.tls_required = tls_required if tls_required is not None else False
7645        self.username = username if username is not None else ''
7646
7647    def __repr__(self):
7648        return '<sdm.MongoLegacyHost ' + \
7649            'auth_database: ' + repr(self.auth_database) + ' ' +\
7650            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7651            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7652            'healthy: ' + repr(self.healthy) + ' ' +\
7653            'hostname: ' + repr(self.hostname) + ' ' +\
7654            'id: ' + repr(self.id) + ' ' +\
7655            'name: ' + repr(self.name) + ' ' +\
7656            'password: ' + repr(self.password) + ' ' +\
7657            'port: ' + repr(self.port) + ' ' +\
7658            'port_override: ' + repr(self.port_override) + ' ' +\
7659            'replica_set: ' + repr(self.replica_set) + ' ' +\
7660            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7661            'tags: ' + repr(self.tags) + ' ' +\
7662            'tls_required: ' + repr(self.tls_required) + ' ' +\
7663            'username: ' + repr(self.username) + ' ' +\
7664            '>'
7665
7666    def to_dict(self):
7667        return {
7668            'auth_database': self.auth_database,
7669            'bind_interface': self.bind_interface,
7670            'egress_filter': self.egress_filter,
7671            'healthy': self.healthy,
7672            'hostname': self.hostname,
7673            'id': self.id,
7674            'name': self.name,
7675            'password': self.password,
7676            'port': self.port,
7677            'port_override': self.port_override,
7678            'replica_set': self.replica_set,
7679            'secret_store_id': self.secret_store_id,
7680            'tags': self.tags,
7681            'tls_required': self.tls_required,
7682            'username': self.username,
7683        }
7684
7685    @classmethod
7686    def from_dict(cls, d):
7687        return cls(
7688            auth_database=d.get('auth_database'),
7689            bind_interface=d.get('bind_interface'),
7690            egress_filter=d.get('egress_filter'),
7691            healthy=d.get('healthy'),
7692            hostname=d.get('hostname'),
7693            id=d.get('id'),
7694            name=d.get('name'),
7695            password=d.get('password'),
7696            port=d.get('port'),
7697            port_override=d.get('port_override'),
7698            replica_set=d.get('replica_set'),
7699            secret_store_id=d.get('secret_store_id'),
7700            tags=d.get('tags'),
7701            tls_required=d.get('tls_required'),
7702            username=d.get('username'),
7703        )
MongoLegacyHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7592    def __init__(
7593        self,
7594        auth_database=None,
7595        bind_interface=None,
7596        egress_filter=None,
7597        healthy=None,
7598        hostname=None,
7599        id=None,
7600        name=None,
7601        password=None,
7602        port=None,
7603        port_override=None,
7604        replica_set=None,
7605        secret_store_id=None,
7606        tags=None,
7607        tls_required=None,
7608        username=None,
7609    ):
7610        self.auth_database = auth_database if auth_database is not None else ''
7611        self.bind_interface = bind_interface if bind_interface is not None else ''
7612        '''
7613         Bind interface
7614        '''
7615        self.egress_filter = egress_filter if egress_filter is not None else ''
7616        '''
7617         A filter applied to the routing logic to pin datasource to nodes.
7618        '''
7619        self.healthy = healthy if healthy is not None else False
7620        '''
7621         True if the datasource is reachable and the credentials are valid.
7622        '''
7623        self.hostname = hostname if hostname is not None else ''
7624        self.id = id if id is not None else ''
7625        '''
7626         Unique identifier of the Resource.
7627        '''
7628        self.name = name if name is not None else ''
7629        '''
7630         Unique human-readable name of the Resource.
7631        '''
7632        self.password = password if password is not None else ''
7633        self.port = port if port is not None else 0
7634        self.port_override = port_override if port_override is not None else 0
7635        self.replica_set = replica_set if replica_set is not None else ''
7636        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7637        '''
7638         ID of the secret store containing credentials for this resource, if any.
7639        '''
7640        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7641        '''
7642         Tags is a map of key, value pairs.
7643        '''
7644        self.tls_required = tls_required if tls_required is not None else False
7645        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7666    def to_dict(self):
7667        return {
7668            'auth_database': self.auth_database,
7669            'bind_interface': self.bind_interface,
7670            'egress_filter': self.egress_filter,
7671            'healthy': self.healthy,
7672            'hostname': self.hostname,
7673            'id': self.id,
7674            'name': self.name,
7675            'password': self.password,
7676            'port': self.port,
7677            'port_override': self.port_override,
7678            'replica_set': self.replica_set,
7679            'secret_store_id': self.secret_store_id,
7680            'tags': self.tags,
7681            'tls_required': self.tls_required,
7682            'username': self.username,
7683        }
@classmethod
def from_dict(cls, d)
7685    @classmethod
7686    def from_dict(cls, d):
7687        return cls(
7688            auth_database=d.get('auth_database'),
7689            bind_interface=d.get('bind_interface'),
7690            egress_filter=d.get('egress_filter'),
7691            healthy=d.get('healthy'),
7692            hostname=d.get('hostname'),
7693            id=d.get('id'),
7694            name=d.get('name'),
7695            password=d.get('password'),
7696            port=d.get('port'),
7697            port_override=d.get('port_override'),
7698            replica_set=d.get('replica_set'),
7699            secret_store_id=d.get('secret_store_id'),
7700            tags=d.get('tags'),
7701            tls_required=d.get('tls_required'),
7702            username=d.get('username'),
7703        )
class MongoLegacyReplicaset:
7706class MongoLegacyReplicaset:
7707    __slots__ = [
7708        'auth_database',
7709        'bind_interface',
7710        'connect_to_replica',
7711        'egress_filter',
7712        'healthy',
7713        'hostname',
7714        'id',
7715        'name',
7716        'password',
7717        'port',
7718        'port_override',
7719        'replica_set',
7720        'secret_store_id',
7721        'tags',
7722        'tls_required',
7723        'username',
7724    ]
7725
7726    def __init__(
7727        self,
7728        auth_database=None,
7729        bind_interface=None,
7730        connect_to_replica=None,
7731        egress_filter=None,
7732        healthy=None,
7733        hostname=None,
7734        id=None,
7735        name=None,
7736        password=None,
7737        port=None,
7738        port_override=None,
7739        replica_set=None,
7740        secret_store_id=None,
7741        tags=None,
7742        tls_required=None,
7743        username=None,
7744    ):
7745        self.auth_database = auth_database if auth_database is not None else ''
7746        self.bind_interface = bind_interface if bind_interface is not None else ''
7747        '''
7748         Bind interface
7749        '''
7750        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7751        self.egress_filter = egress_filter if egress_filter is not None else ''
7752        '''
7753         A filter applied to the routing logic to pin datasource to nodes.
7754        '''
7755        self.healthy = healthy if healthy is not None else False
7756        '''
7757         True if the datasource is reachable and the credentials are valid.
7758        '''
7759        self.hostname = hostname if hostname is not None else ''
7760        self.id = id if id is not None else ''
7761        '''
7762         Unique identifier of the Resource.
7763        '''
7764        self.name = name if name is not None else ''
7765        '''
7766         Unique human-readable name of the Resource.
7767        '''
7768        self.password = password if password is not None else ''
7769        self.port = port if port is not None else 0
7770        self.port_override = port_override if port_override is not None else 0
7771        self.replica_set = replica_set if replica_set is not None else ''
7772        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7773        '''
7774         ID of the secret store containing credentials for this resource, if any.
7775        '''
7776        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7777        '''
7778         Tags is a map of key, value pairs.
7779        '''
7780        self.tls_required = tls_required if tls_required is not None else False
7781        self.username = username if username is not None else ''
7782
7783    def __repr__(self):
7784        return '<sdm.MongoLegacyReplicaset ' + \
7785            'auth_database: ' + repr(self.auth_database) + ' ' +\
7786            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7787            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7788            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7789            'healthy: ' + repr(self.healthy) + ' ' +\
7790            'hostname: ' + repr(self.hostname) + ' ' +\
7791            'id: ' + repr(self.id) + ' ' +\
7792            'name: ' + repr(self.name) + ' ' +\
7793            'password: ' + repr(self.password) + ' ' +\
7794            'port: ' + repr(self.port) + ' ' +\
7795            'port_override: ' + repr(self.port_override) + ' ' +\
7796            'replica_set: ' + repr(self.replica_set) + ' ' +\
7797            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7798            'tags: ' + repr(self.tags) + ' ' +\
7799            'tls_required: ' + repr(self.tls_required) + ' ' +\
7800            'username: ' + repr(self.username) + ' ' +\
7801            '>'
7802
7803    def to_dict(self):
7804        return {
7805            'auth_database': self.auth_database,
7806            'bind_interface': self.bind_interface,
7807            'connect_to_replica': self.connect_to_replica,
7808            'egress_filter': self.egress_filter,
7809            'healthy': self.healthy,
7810            'hostname': self.hostname,
7811            'id': self.id,
7812            'name': self.name,
7813            'password': self.password,
7814            'port': self.port,
7815            'port_override': self.port_override,
7816            'replica_set': self.replica_set,
7817            'secret_store_id': self.secret_store_id,
7818            'tags': self.tags,
7819            'tls_required': self.tls_required,
7820            'username': self.username,
7821        }
7822
7823    @classmethod
7824    def from_dict(cls, d):
7825        return cls(
7826            auth_database=d.get('auth_database'),
7827            bind_interface=d.get('bind_interface'),
7828            connect_to_replica=d.get('connect_to_replica'),
7829            egress_filter=d.get('egress_filter'),
7830            healthy=d.get('healthy'),
7831            hostname=d.get('hostname'),
7832            id=d.get('id'),
7833            name=d.get('name'),
7834            password=d.get('password'),
7835            port=d.get('port'),
7836            port_override=d.get('port_override'),
7837            replica_set=d.get('replica_set'),
7838            secret_store_id=d.get('secret_store_id'),
7839            tags=d.get('tags'),
7840            tls_required=d.get('tls_required'),
7841            username=d.get('username'),
7842        )
MongoLegacyReplicaset( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7726    def __init__(
7727        self,
7728        auth_database=None,
7729        bind_interface=None,
7730        connect_to_replica=None,
7731        egress_filter=None,
7732        healthy=None,
7733        hostname=None,
7734        id=None,
7735        name=None,
7736        password=None,
7737        port=None,
7738        port_override=None,
7739        replica_set=None,
7740        secret_store_id=None,
7741        tags=None,
7742        tls_required=None,
7743        username=None,
7744    ):
7745        self.auth_database = auth_database if auth_database is not None else ''
7746        self.bind_interface = bind_interface if bind_interface is not None else ''
7747        '''
7748         Bind interface
7749        '''
7750        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7751        self.egress_filter = egress_filter if egress_filter is not None else ''
7752        '''
7753         A filter applied to the routing logic to pin datasource to nodes.
7754        '''
7755        self.healthy = healthy if healthy is not None else False
7756        '''
7757         True if the datasource is reachable and the credentials are valid.
7758        '''
7759        self.hostname = hostname if hostname is not None else ''
7760        self.id = id if id is not None else ''
7761        '''
7762         Unique identifier of the Resource.
7763        '''
7764        self.name = name if name is not None else ''
7765        '''
7766         Unique human-readable name of the Resource.
7767        '''
7768        self.password = password if password is not None else ''
7769        self.port = port if port is not None else 0
7770        self.port_override = port_override if port_override is not None else 0
7771        self.replica_set = replica_set if replica_set is not None else ''
7772        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7773        '''
7774         ID of the secret store containing credentials for this resource, if any.
7775        '''
7776        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7777        '''
7778         Tags is a map of key, value pairs.
7779        '''
7780        self.tls_required = tls_required if tls_required is not None else False
7781        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7803    def to_dict(self):
7804        return {
7805            'auth_database': self.auth_database,
7806            'bind_interface': self.bind_interface,
7807            'connect_to_replica': self.connect_to_replica,
7808            'egress_filter': self.egress_filter,
7809            'healthy': self.healthy,
7810            'hostname': self.hostname,
7811            'id': self.id,
7812            'name': self.name,
7813            'password': self.password,
7814            'port': self.port,
7815            'port_override': self.port_override,
7816            'replica_set': self.replica_set,
7817            'secret_store_id': self.secret_store_id,
7818            'tags': self.tags,
7819            'tls_required': self.tls_required,
7820            'username': self.username,
7821        }
@classmethod
def from_dict(cls, d)
7823    @classmethod
7824    def from_dict(cls, d):
7825        return cls(
7826            auth_database=d.get('auth_database'),
7827            bind_interface=d.get('bind_interface'),
7828            connect_to_replica=d.get('connect_to_replica'),
7829            egress_filter=d.get('egress_filter'),
7830            healthy=d.get('healthy'),
7831            hostname=d.get('hostname'),
7832            id=d.get('id'),
7833            name=d.get('name'),
7834            password=d.get('password'),
7835            port=d.get('port'),
7836            port_override=d.get('port_override'),
7837            replica_set=d.get('replica_set'),
7838            secret_store_id=d.get('secret_store_id'),
7839            tags=d.get('tags'),
7840            tls_required=d.get('tls_required'),
7841            username=d.get('username'),
7842        )
class MongoReplicaSet:
7845class MongoReplicaSet:
7846    '''
7847    MongoReplicaSet is currently unstable, and its API may change, or it may be removed,
7848    without a major version bump.
7849    '''
7850    __slots__ = [
7851        'auth_database',
7852        'bind_interface',
7853        'connect_to_replica',
7854        'egress_filter',
7855        'healthy',
7856        'hostname',
7857        'id',
7858        'name',
7859        'password',
7860        'port',
7861        'port_override',
7862        'replica_set',
7863        'secret_store_id',
7864        'tags',
7865        'tls_required',
7866        'username',
7867    ]
7868
7869    def __init__(
7870        self,
7871        auth_database=None,
7872        bind_interface=None,
7873        connect_to_replica=None,
7874        egress_filter=None,
7875        healthy=None,
7876        hostname=None,
7877        id=None,
7878        name=None,
7879        password=None,
7880        port=None,
7881        port_override=None,
7882        replica_set=None,
7883        secret_store_id=None,
7884        tags=None,
7885        tls_required=None,
7886        username=None,
7887    ):
7888        self.auth_database = auth_database if auth_database is not None else ''
7889        self.bind_interface = bind_interface if bind_interface is not None else ''
7890        '''
7891         Bind interface
7892        '''
7893        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7894        self.egress_filter = egress_filter if egress_filter is not None else ''
7895        '''
7896         A filter applied to the routing logic to pin datasource to nodes.
7897        '''
7898        self.healthy = healthy if healthy is not None else False
7899        '''
7900         True if the datasource is reachable and the credentials are valid.
7901        '''
7902        self.hostname = hostname if hostname is not None else ''
7903        self.id = id if id is not None else ''
7904        '''
7905         Unique identifier of the Resource.
7906        '''
7907        self.name = name if name is not None else ''
7908        '''
7909         Unique human-readable name of the Resource.
7910        '''
7911        self.password = password if password is not None else ''
7912        self.port = port if port is not None else 0
7913        self.port_override = port_override if port_override is not None else 0
7914        self.replica_set = replica_set if replica_set is not None else ''
7915        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7916        '''
7917         ID of the secret store containing credentials for this resource, if any.
7918        '''
7919        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7920        '''
7921         Tags is a map of key, value pairs.
7922        '''
7923        self.tls_required = tls_required if tls_required is not None else False
7924        self.username = username if username is not None else ''
7925
7926    def __repr__(self):
7927        return '<sdm.MongoReplicaSet ' + \
7928            'auth_database: ' + repr(self.auth_database) + ' ' +\
7929            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7930            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
7931            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7932            'healthy: ' + repr(self.healthy) + ' ' +\
7933            'hostname: ' + repr(self.hostname) + ' ' +\
7934            'id: ' + repr(self.id) + ' ' +\
7935            'name: ' + repr(self.name) + ' ' +\
7936            'password: ' + repr(self.password) + ' ' +\
7937            'port: ' + repr(self.port) + ' ' +\
7938            'port_override: ' + repr(self.port_override) + ' ' +\
7939            'replica_set: ' + repr(self.replica_set) + ' ' +\
7940            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7941            'tags: ' + repr(self.tags) + ' ' +\
7942            'tls_required: ' + repr(self.tls_required) + ' ' +\
7943            'username: ' + repr(self.username) + ' ' +\
7944            '>'
7945
7946    def to_dict(self):
7947        return {
7948            'auth_database': self.auth_database,
7949            'bind_interface': self.bind_interface,
7950            'connect_to_replica': self.connect_to_replica,
7951            'egress_filter': self.egress_filter,
7952            'healthy': self.healthy,
7953            'hostname': self.hostname,
7954            'id': self.id,
7955            'name': self.name,
7956            'password': self.password,
7957            'port': self.port,
7958            'port_override': self.port_override,
7959            'replica_set': self.replica_set,
7960            'secret_store_id': self.secret_store_id,
7961            'tags': self.tags,
7962            'tls_required': self.tls_required,
7963            'username': self.username,
7964        }
7965
7966    @classmethod
7967    def from_dict(cls, d):
7968        return cls(
7969            auth_database=d.get('auth_database'),
7970            bind_interface=d.get('bind_interface'),
7971            connect_to_replica=d.get('connect_to_replica'),
7972            egress_filter=d.get('egress_filter'),
7973            healthy=d.get('healthy'),
7974            hostname=d.get('hostname'),
7975            id=d.get('id'),
7976            name=d.get('name'),
7977            password=d.get('password'),
7978            port=d.get('port'),
7979            port_override=d.get('port_override'),
7980            replica_set=d.get('replica_set'),
7981            secret_store_id=d.get('secret_store_id'),
7982            tags=d.get('tags'),
7983            tls_required=d.get('tls_required'),
7984            username=d.get('username'),
7985        )

MongoReplicaSet is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7869    def __init__(
7870        self,
7871        auth_database=None,
7872        bind_interface=None,
7873        connect_to_replica=None,
7874        egress_filter=None,
7875        healthy=None,
7876        hostname=None,
7877        id=None,
7878        name=None,
7879        password=None,
7880        port=None,
7881        port_override=None,
7882        replica_set=None,
7883        secret_store_id=None,
7884        tags=None,
7885        tls_required=None,
7886        username=None,
7887    ):
7888        self.auth_database = auth_database if auth_database is not None else ''
7889        self.bind_interface = bind_interface if bind_interface is not None else ''
7890        '''
7891         Bind interface
7892        '''
7893        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
7894        self.egress_filter = egress_filter if egress_filter is not None else ''
7895        '''
7896         A filter applied to the routing logic to pin datasource to nodes.
7897        '''
7898        self.healthy = healthy if healthy is not None else False
7899        '''
7900         True if the datasource is reachable and the credentials are valid.
7901        '''
7902        self.hostname = hostname if hostname is not None else ''
7903        self.id = id if id is not None else ''
7904        '''
7905         Unique identifier of the Resource.
7906        '''
7907        self.name = name if name is not None else ''
7908        '''
7909         Unique human-readable name of the Resource.
7910        '''
7911        self.password = password if password is not None else ''
7912        self.port = port if port is not None else 0
7913        self.port_override = port_override if port_override is not None else 0
7914        self.replica_set = replica_set if replica_set is not None else ''
7915        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7916        '''
7917         ID of the secret store containing credentials for this resource, if any.
7918        '''
7919        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7920        '''
7921         Tags is a map of key, value pairs.
7922        '''
7923        self.tls_required = tls_required if tls_required is not None else False
7924        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7946    def to_dict(self):
7947        return {
7948            'auth_database': self.auth_database,
7949            'bind_interface': self.bind_interface,
7950            'connect_to_replica': self.connect_to_replica,
7951            'egress_filter': self.egress_filter,
7952            'healthy': self.healthy,
7953            'hostname': self.hostname,
7954            'id': self.id,
7955            'name': self.name,
7956            'password': self.password,
7957            'port': self.port,
7958            'port_override': self.port_override,
7959            'replica_set': self.replica_set,
7960            'secret_store_id': self.secret_store_id,
7961            'tags': self.tags,
7962            'tls_required': self.tls_required,
7963            'username': self.username,
7964        }
@classmethod
def from_dict(cls, d)
7966    @classmethod
7967    def from_dict(cls, d):
7968        return cls(
7969            auth_database=d.get('auth_database'),
7970            bind_interface=d.get('bind_interface'),
7971            connect_to_replica=d.get('connect_to_replica'),
7972            egress_filter=d.get('egress_filter'),
7973            healthy=d.get('healthy'),
7974            hostname=d.get('hostname'),
7975            id=d.get('id'),
7976            name=d.get('name'),
7977            password=d.get('password'),
7978            port=d.get('port'),
7979            port_override=d.get('port_override'),
7980            replica_set=d.get('replica_set'),
7981            secret_store_id=d.get('secret_store_id'),
7982            tags=d.get('tags'),
7983            tls_required=d.get('tls_required'),
7984            username=d.get('username'),
7985        )
class MongoShardedCluster:
7988class MongoShardedCluster:
7989    '''
7990    MongoShardedCluster is currently unstable, and its API may change, or it may be removed,
7991    without a major version bump.
7992    '''
7993    __slots__ = [
7994        'auth_database',
7995        'bind_interface',
7996        'egress_filter',
7997        'healthy',
7998        'hostname',
7999        'id',
8000        'name',
8001        'password',
8002        'port_override',
8003        'secret_store_id',
8004        'tags',
8005        'tls_required',
8006        'username',
8007    ]
8008
8009    def __init__(
8010        self,
8011        auth_database=None,
8012        bind_interface=None,
8013        egress_filter=None,
8014        healthy=None,
8015        hostname=None,
8016        id=None,
8017        name=None,
8018        password=None,
8019        port_override=None,
8020        secret_store_id=None,
8021        tags=None,
8022        tls_required=None,
8023        username=None,
8024    ):
8025        self.auth_database = auth_database if auth_database is not None else ''
8026        self.bind_interface = bind_interface if bind_interface is not None else ''
8027        '''
8028         Bind interface
8029        '''
8030        self.egress_filter = egress_filter if egress_filter is not None else ''
8031        '''
8032         A filter applied to the routing logic to pin datasource to nodes.
8033        '''
8034        self.healthy = healthy if healthy is not None else False
8035        '''
8036         True if the datasource is reachable and the credentials are valid.
8037        '''
8038        self.hostname = hostname if hostname is not None else ''
8039        self.id = id if id is not None else ''
8040        '''
8041         Unique identifier of the Resource.
8042        '''
8043        self.name = name if name is not None else ''
8044        '''
8045         Unique human-readable name of the Resource.
8046        '''
8047        self.password = password if password is not None else ''
8048        self.port_override = port_override if port_override is not None else 0
8049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8050        '''
8051         ID of the secret store containing credentials for this resource, if any.
8052        '''
8053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8054        '''
8055         Tags is a map of key, value pairs.
8056        '''
8057        self.tls_required = tls_required if tls_required is not None else False
8058        self.username = username if username is not None else ''
8059
8060    def __repr__(self):
8061        return '<sdm.MongoShardedCluster ' + \
8062            'auth_database: ' + repr(self.auth_database) + ' ' +\
8063            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8064            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8065            'healthy: ' + repr(self.healthy) + ' ' +\
8066            'hostname: ' + repr(self.hostname) + ' ' +\
8067            'id: ' + repr(self.id) + ' ' +\
8068            'name: ' + repr(self.name) + ' ' +\
8069            'password: ' + repr(self.password) + ' ' +\
8070            'port_override: ' + repr(self.port_override) + ' ' +\
8071            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8072            'tags: ' + repr(self.tags) + ' ' +\
8073            'tls_required: ' + repr(self.tls_required) + ' ' +\
8074            'username: ' + repr(self.username) + ' ' +\
8075            '>'
8076
8077    def to_dict(self):
8078        return {
8079            'auth_database': self.auth_database,
8080            'bind_interface': self.bind_interface,
8081            'egress_filter': self.egress_filter,
8082            'healthy': self.healthy,
8083            'hostname': self.hostname,
8084            'id': self.id,
8085            'name': self.name,
8086            'password': self.password,
8087            'port_override': self.port_override,
8088            'secret_store_id': self.secret_store_id,
8089            'tags': self.tags,
8090            'tls_required': self.tls_required,
8091            'username': self.username,
8092        }
8093
8094    @classmethod
8095    def from_dict(cls, d):
8096        return cls(
8097            auth_database=d.get('auth_database'),
8098            bind_interface=d.get('bind_interface'),
8099            egress_filter=d.get('egress_filter'),
8100            healthy=d.get('healthy'),
8101            hostname=d.get('hostname'),
8102            id=d.get('id'),
8103            name=d.get('name'),
8104            password=d.get('password'),
8105            port_override=d.get('port_override'),
8106            secret_store_id=d.get('secret_store_id'),
8107            tags=d.get('tags'),
8108            tls_required=d.get('tls_required'),
8109            username=d.get('username'),
8110        )

MongoShardedCluster is currently unstable, and its API may change, or it may be removed, without a major version bump.

MongoShardedCluster( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8009    def __init__(
8010        self,
8011        auth_database=None,
8012        bind_interface=None,
8013        egress_filter=None,
8014        healthy=None,
8015        hostname=None,
8016        id=None,
8017        name=None,
8018        password=None,
8019        port_override=None,
8020        secret_store_id=None,
8021        tags=None,
8022        tls_required=None,
8023        username=None,
8024    ):
8025        self.auth_database = auth_database if auth_database is not None else ''
8026        self.bind_interface = bind_interface if bind_interface is not None else ''
8027        '''
8028         Bind interface
8029        '''
8030        self.egress_filter = egress_filter if egress_filter is not None else ''
8031        '''
8032         A filter applied to the routing logic to pin datasource to nodes.
8033        '''
8034        self.healthy = healthy if healthy is not None else False
8035        '''
8036         True if the datasource is reachable and the credentials are valid.
8037        '''
8038        self.hostname = hostname if hostname is not None else ''
8039        self.id = id if id is not None else ''
8040        '''
8041         Unique identifier of the Resource.
8042        '''
8043        self.name = name if name is not None else ''
8044        '''
8045         Unique human-readable name of the Resource.
8046        '''
8047        self.password = password if password is not None else ''
8048        self.port_override = port_override if port_override is not None else 0
8049        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8050        '''
8051         ID of the secret store containing credentials for this resource, if any.
8052        '''
8053        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8054        '''
8055         Tags is a map of key, value pairs.
8056        '''
8057        self.tls_required = tls_required if tls_required is not None else False
8058        self.username = username if username is not None else ''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8077    def to_dict(self):
8078        return {
8079            'auth_database': self.auth_database,
8080            'bind_interface': self.bind_interface,
8081            'egress_filter': self.egress_filter,
8082            'healthy': self.healthy,
8083            'hostname': self.hostname,
8084            'id': self.id,
8085            'name': self.name,
8086            'password': self.password,
8087            'port_override': self.port_override,
8088            'secret_store_id': self.secret_store_id,
8089            'tags': self.tags,
8090            'tls_required': self.tls_required,
8091            'username': self.username,
8092        }
@classmethod
def from_dict(cls, d)
8094    @classmethod
8095    def from_dict(cls, d):
8096        return cls(
8097            auth_database=d.get('auth_database'),
8098            bind_interface=d.get('bind_interface'),
8099            egress_filter=d.get('egress_filter'),
8100            healthy=d.get('healthy'),
8101            hostname=d.get('hostname'),
8102            id=d.get('id'),
8103            name=d.get('name'),
8104            password=d.get('password'),
8105            port_override=d.get('port_override'),
8106            secret_store_id=d.get('secret_store_id'),
8107            tags=d.get('tags'),
8108            tls_required=d.get('tls_required'),
8109            username=d.get('username'),
8110        )
class Mysql:
8113class Mysql:
8114    __slots__ = [
8115        'bind_interface',
8116        'database',
8117        'egress_filter',
8118        'healthy',
8119        'hostname',
8120        'id',
8121        'name',
8122        'password',
8123        'port',
8124        'port_override',
8125        'secret_store_id',
8126        'tags',
8127        'username',
8128    ]
8129
8130    def __init__(
8131        self,
8132        bind_interface=None,
8133        database=None,
8134        egress_filter=None,
8135        healthy=None,
8136        hostname=None,
8137        id=None,
8138        name=None,
8139        password=None,
8140        port=None,
8141        port_override=None,
8142        secret_store_id=None,
8143        tags=None,
8144        username=None,
8145    ):
8146        self.bind_interface = bind_interface if bind_interface is not None else ''
8147        '''
8148         Bind interface
8149        '''
8150        self.database = database if database is not None else ''
8151        self.egress_filter = egress_filter if egress_filter is not None else ''
8152        '''
8153         A filter applied to the routing logic to pin datasource to nodes.
8154        '''
8155        self.healthy = healthy if healthy is not None else False
8156        '''
8157         True if the datasource is reachable and the credentials are valid.
8158        '''
8159        self.hostname = hostname if hostname is not None else ''
8160        self.id = id if id is not None else ''
8161        '''
8162         Unique identifier of the Resource.
8163        '''
8164        self.name = name if name is not None else ''
8165        '''
8166         Unique human-readable name of the Resource.
8167        '''
8168        self.password = password if password is not None else ''
8169        self.port = port if port is not None else 0
8170        self.port_override = port_override if port_override is not None else 0
8171        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8172        '''
8173         ID of the secret store containing credentials for this resource, if any.
8174        '''
8175        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8176        '''
8177         Tags is a map of key, value pairs.
8178        '''
8179        self.username = username if username is not None else ''
8180
8181    def __repr__(self):
8182        return '<sdm.Mysql ' + \
8183            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8184            'database: ' + repr(self.database) + ' ' +\
8185            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8186            'healthy: ' + repr(self.healthy) + ' ' +\
8187            'hostname: ' + repr(self.hostname) + ' ' +\
8188            'id: ' + repr(self.id) + ' ' +\
8189            'name: ' + repr(self.name) + ' ' +\
8190            'password: ' + repr(self.password) + ' ' +\
8191            'port: ' + repr(self.port) + ' ' +\
8192            'port_override: ' + repr(self.port_override) + ' ' +\
8193            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8194            'tags: ' + repr(self.tags) + ' ' +\
8195            'username: ' + repr(self.username) + ' ' +\
8196            '>'
8197
8198    def to_dict(self):
8199        return {
8200            'bind_interface': self.bind_interface,
8201            'database': self.database,
8202            'egress_filter': self.egress_filter,
8203            'healthy': self.healthy,
8204            'hostname': self.hostname,
8205            'id': self.id,
8206            'name': self.name,
8207            'password': self.password,
8208            'port': self.port,
8209            'port_override': self.port_override,
8210            'secret_store_id': self.secret_store_id,
8211            'tags': self.tags,
8212            'username': self.username,
8213        }
8214
8215    @classmethod
8216    def from_dict(cls, d):
8217        return cls(
8218            bind_interface=d.get('bind_interface'),
8219            database=d.get('database'),
8220            egress_filter=d.get('egress_filter'),
8221            healthy=d.get('healthy'),
8222            hostname=d.get('hostname'),
8223            id=d.get('id'),
8224            name=d.get('name'),
8225            password=d.get('password'),
8226            port=d.get('port'),
8227            port_override=d.get('port_override'),
8228            secret_store_id=d.get('secret_store_id'),
8229            tags=d.get('tags'),
8230            username=d.get('username'),
8231        )
Mysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8130    def __init__(
8131        self,
8132        bind_interface=None,
8133        database=None,
8134        egress_filter=None,
8135        healthy=None,
8136        hostname=None,
8137        id=None,
8138        name=None,
8139        password=None,
8140        port=None,
8141        port_override=None,
8142        secret_store_id=None,
8143        tags=None,
8144        username=None,
8145    ):
8146        self.bind_interface = bind_interface if bind_interface is not None else ''
8147        '''
8148         Bind interface
8149        '''
8150        self.database = database if database is not None else ''
8151        self.egress_filter = egress_filter if egress_filter is not None else ''
8152        '''
8153         A filter applied to the routing logic to pin datasource to nodes.
8154        '''
8155        self.healthy = healthy if healthy is not None else False
8156        '''
8157         True if the datasource is reachable and the credentials are valid.
8158        '''
8159        self.hostname = hostname if hostname is not None else ''
8160        self.id = id if id is not None else ''
8161        '''
8162         Unique identifier of the Resource.
8163        '''
8164        self.name = name if name is not None else ''
8165        '''
8166         Unique human-readable name of the Resource.
8167        '''
8168        self.password = password if password is not None else ''
8169        self.port = port if port is not None else 0
8170        self.port_override = port_override if port_override is not None else 0
8171        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8172        '''
8173         ID of the secret store containing credentials for this resource, if any.
8174        '''
8175        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8176        '''
8177         Tags is a map of key, value pairs.
8178        '''
8179        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8198    def to_dict(self):
8199        return {
8200            'bind_interface': self.bind_interface,
8201            'database': self.database,
8202            'egress_filter': self.egress_filter,
8203            'healthy': self.healthy,
8204            'hostname': self.hostname,
8205            'id': self.id,
8206            'name': self.name,
8207            'password': self.password,
8208            'port': self.port,
8209            'port_override': self.port_override,
8210            'secret_store_id': self.secret_store_id,
8211            'tags': self.tags,
8212            'username': self.username,
8213        }
@classmethod
def from_dict(cls, d)
8215    @classmethod
8216    def from_dict(cls, d):
8217        return cls(
8218            bind_interface=d.get('bind_interface'),
8219            database=d.get('database'),
8220            egress_filter=d.get('egress_filter'),
8221            healthy=d.get('healthy'),
8222            hostname=d.get('hostname'),
8223            id=d.get('id'),
8224            name=d.get('name'),
8225            password=d.get('password'),
8226            port=d.get('port'),
8227            port_override=d.get('port_override'),
8228            secret_store_id=d.get('secret_store_id'),
8229            tags=d.get('tags'),
8230            username=d.get('username'),
8231        )
class Neptune:
8234class Neptune:
8235    __slots__ = [
8236        'bind_interface',
8237        'egress_filter',
8238        'endpoint',
8239        'healthy',
8240        'id',
8241        'name',
8242        'port',
8243        'port_override',
8244        'secret_store_id',
8245        'tags',
8246    ]
8247
8248    def __init__(
8249        self,
8250        bind_interface=None,
8251        egress_filter=None,
8252        endpoint=None,
8253        healthy=None,
8254        id=None,
8255        name=None,
8256        port=None,
8257        port_override=None,
8258        secret_store_id=None,
8259        tags=None,
8260    ):
8261        self.bind_interface = bind_interface if bind_interface is not None else ''
8262        '''
8263         Bind interface
8264        '''
8265        self.egress_filter = egress_filter if egress_filter is not None else ''
8266        '''
8267         A filter applied to the routing logic to pin datasource to nodes.
8268        '''
8269        self.endpoint = endpoint if endpoint is not None else ''
8270        self.healthy = healthy if healthy is not None else False
8271        '''
8272         True if the datasource is reachable and the credentials are valid.
8273        '''
8274        self.id = id if id is not None else ''
8275        '''
8276         Unique identifier of the Resource.
8277        '''
8278        self.name = name if name is not None else ''
8279        '''
8280         Unique human-readable name of the Resource.
8281        '''
8282        self.port = port if port is not None else 0
8283        self.port_override = port_override if port_override is not None else 0
8284        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8285        '''
8286         ID of the secret store containing credentials for this resource, if any.
8287        '''
8288        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8289        '''
8290         Tags is a map of key, value pairs.
8291        '''
8292
8293    def __repr__(self):
8294        return '<sdm.Neptune ' + \
8295            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8296            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8297            'endpoint: ' + repr(self.endpoint) + ' ' +\
8298            'healthy: ' + repr(self.healthy) + ' ' +\
8299            'id: ' + repr(self.id) + ' ' +\
8300            'name: ' + repr(self.name) + ' ' +\
8301            'port: ' + repr(self.port) + ' ' +\
8302            'port_override: ' + repr(self.port_override) + ' ' +\
8303            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8304            'tags: ' + repr(self.tags) + ' ' +\
8305            '>'
8306
8307    def to_dict(self):
8308        return {
8309            'bind_interface': self.bind_interface,
8310            'egress_filter': self.egress_filter,
8311            'endpoint': self.endpoint,
8312            'healthy': self.healthy,
8313            'id': self.id,
8314            'name': self.name,
8315            'port': self.port,
8316            'port_override': self.port_override,
8317            'secret_store_id': self.secret_store_id,
8318            'tags': self.tags,
8319        }
8320
8321    @classmethod
8322    def from_dict(cls, d):
8323        return cls(
8324            bind_interface=d.get('bind_interface'),
8325            egress_filter=d.get('egress_filter'),
8326            endpoint=d.get('endpoint'),
8327            healthy=d.get('healthy'),
8328            id=d.get('id'),
8329            name=d.get('name'),
8330            port=d.get('port'),
8331            port_override=d.get('port_override'),
8332            secret_store_id=d.get('secret_store_id'),
8333            tags=d.get('tags'),
8334        )
Neptune( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
8248    def __init__(
8249        self,
8250        bind_interface=None,
8251        egress_filter=None,
8252        endpoint=None,
8253        healthy=None,
8254        id=None,
8255        name=None,
8256        port=None,
8257        port_override=None,
8258        secret_store_id=None,
8259        tags=None,
8260    ):
8261        self.bind_interface = bind_interface if bind_interface is not None else ''
8262        '''
8263         Bind interface
8264        '''
8265        self.egress_filter = egress_filter if egress_filter is not None else ''
8266        '''
8267         A filter applied to the routing logic to pin datasource to nodes.
8268        '''
8269        self.endpoint = endpoint if endpoint is not None else ''
8270        self.healthy = healthy if healthy is not None else False
8271        '''
8272         True if the datasource is reachable and the credentials are valid.
8273        '''
8274        self.id = id if id is not None else ''
8275        '''
8276         Unique identifier of the Resource.
8277        '''
8278        self.name = name if name is not None else ''
8279        '''
8280         Unique human-readable name of the Resource.
8281        '''
8282        self.port = port if port is not None else 0
8283        self.port_override = port_override if port_override is not None else 0
8284        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8285        '''
8286         ID of the secret store containing credentials for this resource, if any.
8287        '''
8288        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8289        '''
8290         Tags is a map of key, value pairs.
8291        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8307    def to_dict(self):
8308        return {
8309            'bind_interface': self.bind_interface,
8310            'egress_filter': self.egress_filter,
8311            'endpoint': self.endpoint,
8312            'healthy': self.healthy,
8313            'id': self.id,
8314            'name': self.name,
8315            'port': self.port,
8316            'port_override': self.port_override,
8317            'secret_store_id': self.secret_store_id,
8318            'tags': self.tags,
8319        }
@classmethod
def from_dict(cls, d)
8321    @classmethod
8322    def from_dict(cls, d):
8323        return cls(
8324            bind_interface=d.get('bind_interface'),
8325            egress_filter=d.get('egress_filter'),
8326            endpoint=d.get('endpoint'),
8327            healthy=d.get('healthy'),
8328            id=d.get('id'),
8329            name=d.get('name'),
8330            port=d.get('port'),
8331            port_override=d.get('port_override'),
8332            secret_store_id=d.get('secret_store_id'),
8333            tags=d.get('tags'),
8334        )
class NeptuneIAM:
8337class NeptuneIAM:
8338    __slots__ = [
8339        'access_key',
8340        'bind_interface',
8341        'egress_filter',
8342        'endpoint',
8343        'healthy',
8344        'id',
8345        'name',
8346        'port',
8347        'port_override',
8348        'region',
8349        'role_arn',
8350        'role_external_id',
8351        'secret_access_key',
8352        'secret_store_id',
8353        'tags',
8354    ]
8355
8356    def __init__(
8357        self,
8358        access_key=None,
8359        bind_interface=None,
8360        egress_filter=None,
8361        endpoint=None,
8362        healthy=None,
8363        id=None,
8364        name=None,
8365        port=None,
8366        port_override=None,
8367        region=None,
8368        role_arn=None,
8369        role_external_id=None,
8370        secret_access_key=None,
8371        secret_store_id=None,
8372        tags=None,
8373    ):
8374        self.access_key = access_key if access_key is not None else ''
8375        self.bind_interface = bind_interface if bind_interface is not None else ''
8376        '''
8377         Bind interface
8378        '''
8379        self.egress_filter = egress_filter if egress_filter is not None else ''
8380        '''
8381         A filter applied to the routing logic to pin datasource to nodes.
8382        '''
8383        self.endpoint = endpoint if endpoint is not None else ''
8384        self.healthy = healthy if healthy is not None else False
8385        '''
8386         True if the datasource is reachable and the credentials are valid.
8387        '''
8388        self.id = id if id is not None else ''
8389        '''
8390         Unique identifier of the Resource.
8391        '''
8392        self.name = name if name is not None else ''
8393        '''
8394         Unique human-readable name of the Resource.
8395        '''
8396        self.port = port if port is not None else 0
8397        self.port_override = port_override if port_override is not None else 0
8398        self.region = region if region is not None else ''
8399        self.role_arn = role_arn if role_arn is not None else ''
8400        self.role_external_id = role_external_id if role_external_id is not None else ''
8401        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8402        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8403        '''
8404         ID of the secret store containing credentials for this resource, if any.
8405        '''
8406        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8407        '''
8408         Tags is a map of key, value pairs.
8409        '''
8410
8411    def __repr__(self):
8412        return '<sdm.NeptuneIAM ' + \
8413            'access_key: ' + repr(self.access_key) + ' ' +\
8414            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8415            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8416            'endpoint: ' + repr(self.endpoint) + ' ' +\
8417            'healthy: ' + repr(self.healthy) + ' ' +\
8418            'id: ' + repr(self.id) + ' ' +\
8419            'name: ' + repr(self.name) + ' ' +\
8420            'port: ' + repr(self.port) + ' ' +\
8421            'port_override: ' + repr(self.port_override) + ' ' +\
8422            'region: ' + repr(self.region) + ' ' +\
8423            'role_arn: ' + repr(self.role_arn) + ' ' +\
8424            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
8425            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
8426            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8427            'tags: ' + repr(self.tags) + ' ' +\
8428            '>'
8429
8430    def to_dict(self):
8431        return {
8432            'access_key': self.access_key,
8433            'bind_interface': self.bind_interface,
8434            'egress_filter': self.egress_filter,
8435            'endpoint': self.endpoint,
8436            'healthy': self.healthy,
8437            'id': self.id,
8438            'name': self.name,
8439            'port': self.port,
8440            'port_override': self.port_override,
8441            'region': self.region,
8442            'role_arn': self.role_arn,
8443            'role_external_id': self.role_external_id,
8444            'secret_access_key': self.secret_access_key,
8445            'secret_store_id': self.secret_store_id,
8446            'tags': self.tags,
8447        }
8448
8449    @classmethod
8450    def from_dict(cls, d):
8451        return cls(
8452            access_key=d.get('access_key'),
8453            bind_interface=d.get('bind_interface'),
8454            egress_filter=d.get('egress_filter'),
8455            endpoint=d.get('endpoint'),
8456            healthy=d.get('healthy'),
8457            id=d.get('id'),
8458            name=d.get('name'),
8459            port=d.get('port'),
8460            port_override=d.get('port_override'),
8461            region=d.get('region'),
8462            role_arn=d.get('role_arn'),
8463            role_external_id=d.get('role_external_id'),
8464            secret_access_key=d.get('secret_access_key'),
8465            secret_store_id=d.get('secret_store_id'),
8466            tags=d.get('tags'),
8467        )
NeptuneIAM( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
8356    def __init__(
8357        self,
8358        access_key=None,
8359        bind_interface=None,
8360        egress_filter=None,
8361        endpoint=None,
8362        healthy=None,
8363        id=None,
8364        name=None,
8365        port=None,
8366        port_override=None,
8367        region=None,
8368        role_arn=None,
8369        role_external_id=None,
8370        secret_access_key=None,
8371        secret_store_id=None,
8372        tags=None,
8373    ):
8374        self.access_key = access_key if access_key is not None else ''
8375        self.bind_interface = bind_interface if bind_interface is not None else ''
8376        '''
8377         Bind interface
8378        '''
8379        self.egress_filter = egress_filter if egress_filter is not None else ''
8380        '''
8381         A filter applied to the routing logic to pin datasource to nodes.
8382        '''
8383        self.endpoint = endpoint if endpoint is not None else ''
8384        self.healthy = healthy if healthy is not None else False
8385        '''
8386         True if the datasource is reachable and the credentials are valid.
8387        '''
8388        self.id = id if id is not None else ''
8389        '''
8390         Unique identifier of the Resource.
8391        '''
8392        self.name = name if name is not None else ''
8393        '''
8394         Unique human-readable name of the Resource.
8395        '''
8396        self.port = port if port is not None else 0
8397        self.port_override = port_override if port_override is not None else 0
8398        self.region = region if region is not None else ''
8399        self.role_arn = role_arn if role_arn is not None else ''
8400        self.role_external_id = role_external_id if role_external_id is not None else ''
8401        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8402        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8403        '''
8404         ID of the secret store containing credentials for this resource, if any.
8405        '''
8406        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8407        '''
8408         Tags is a map of key, value pairs.
8409        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8430    def to_dict(self):
8431        return {
8432            'access_key': self.access_key,
8433            'bind_interface': self.bind_interface,
8434            'egress_filter': self.egress_filter,
8435            'endpoint': self.endpoint,
8436            'healthy': self.healthy,
8437            'id': self.id,
8438            'name': self.name,
8439            'port': self.port,
8440            'port_override': self.port_override,
8441            'region': self.region,
8442            'role_arn': self.role_arn,
8443            'role_external_id': self.role_external_id,
8444            'secret_access_key': self.secret_access_key,
8445            'secret_store_id': self.secret_store_id,
8446            'tags': self.tags,
8447        }
@classmethod
def from_dict(cls, d)
8449    @classmethod
8450    def from_dict(cls, d):
8451        return cls(
8452            access_key=d.get('access_key'),
8453            bind_interface=d.get('bind_interface'),
8454            egress_filter=d.get('egress_filter'),
8455            endpoint=d.get('endpoint'),
8456            healthy=d.get('healthy'),
8457            id=d.get('id'),
8458            name=d.get('name'),
8459            port=d.get('port'),
8460            port_override=d.get('port_override'),
8461            region=d.get('region'),
8462            role_arn=d.get('role_arn'),
8463            role_external_id=d.get('role_external_id'),
8464            secret_access_key=d.get('secret_access_key'),
8465            secret_store_id=d.get('secret_store_id'),
8466            tags=d.get('tags'),
8467        )
class NodeCreateResponse:
8470class NodeCreateResponse:
8471    '''
8472         NodeCreateResponse reports how the Nodes were created in the system.
8473    '''
8474    __slots__ = [
8475        'meta',
8476        'node',
8477        'rate_limit',
8478        'token',
8479    ]
8480
8481    def __init__(
8482        self,
8483        meta=None,
8484        node=None,
8485        rate_limit=None,
8486        token=None,
8487    ):
8488        self.meta = meta if meta is not None else None
8489        '''
8490         Reserved for future use.
8491        '''
8492        self.node = node if node is not None else None
8493        '''
8494         The created Node.
8495        '''
8496        self.rate_limit = rate_limit if rate_limit is not None else None
8497        '''
8498         Rate limit information.
8499        '''
8500        self.token = token if token is not None else ''
8501        '''
8502         The auth token generated for the Node. The Node will use this token to
8503         authenticate with the strongDM API.
8504        '''
8505
8506    def __repr__(self):
8507        return '<sdm.NodeCreateResponse ' + \
8508            'meta: ' + repr(self.meta) + ' ' +\
8509            'node: ' + repr(self.node) + ' ' +\
8510            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8511            'token: ' + repr(self.token) + ' ' +\
8512            '>'
8513
8514    def to_dict(self):
8515        return {
8516            'meta': self.meta,
8517            'node': self.node,
8518            'rate_limit': self.rate_limit,
8519            'token': self.token,
8520        }
8521
8522    @classmethod
8523    def from_dict(cls, d):
8524        return cls(
8525            meta=d.get('meta'),
8526            node=d.get('node'),
8527            rate_limit=d.get('rate_limit'),
8528            token=d.get('token'),
8529        )

NodeCreateResponse reports how the Nodes were created in the system.

NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
8481    def __init__(
8482        self,
8483        meta=None,
8484        node=None,
8485        rate_limit=None,
8486        token=None,
8487    ):
8488        self.meta = meta if meta is not None else None
8489        '''
8490         Reserved for future use.
8491        '''
8492        self.node = node if node is not None else None
8493        '''
8494         The created Node.
8495        '''
8496        self.rate_limit = rate_limit if rate_limit is not None else None
8497        '''
8498         Rate limit information.
8499        '''
8500        self.token = token if token is not None else ''
8501        '''
8502         The auth token generated for the Node. The Node will use this token to
8503         authenticate with the strongDM API.
8504        '''
meta

Reserved for future use.

node

The created Node.

rate_limit

Rate limit information.

token

The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

def to_dict(self)
8514    def to_dict(self):
8515        return {
8516            'meta': self.meta,
8517            'node': self.node,
8518            'rate_limit': self.rate_limit,
8519            'token': self.token,
8520        }
@classmethod
def from_dict(cls, d)
8522    @classmethod
8523    def from_dict(cls, d):
8524        return cls(
8525            meta=d.get('meta'),
8526            node=d.get('node'),
8527            rate_limit=d.get('rate_limit'),
8528            token=d.get('token'),
8529        )
class NodeDeleteResponse:
8532class NodeDeleteResponse:
8533    '''
8534         NodeDeleteResponse returns information about a Node that was deleted.
8535    '''
8536    __slots__ = [
8537        'meta',
8538        'rate_limit',
8539    ]
8540
8541    def __init__(
8542        self,
8543        meta=None,
8544        rate_limit=None,
8545    ):
8546        self.meta = meta if meta is not None else None
8547        '''
8548         Reserved for future use.
8549        '''
8550        self.rate_limit = rate_limit if rate_limit is not None else None
8551        '''
8552         Rate limit information.
8553        '''
8554
8555    def __repr__(self):
8556        return '<sdm.NodeDeleteResponse ' + \
8557            'meta: ' + repr(self.meta) + ' ' +\
8558            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8559            '>'
8560
8561    def to_dict(self):
8562        return {
8563            'meta': self.meta,
8564            'rate_limit': self.rate_limit,
8565        }
8566
8567    @classmethod
8568    def from_dict(cls, d):
8569        return cls(
8570            meta=d.get('meta'),
8571            rate_limit=d.get('rate_limit'),
8572        )

NodeDeleteResponse returns information about a Node that was deleted.

NodeDeleteResponse(meta=None, rate_limit=None)
8541    def __init__(
8542        self,
8543        meta=None,
8544        rate_limit=None,
8545    ):
8546        self.meta = meta if meta is not None else None
8547        '''
8548         Reserved for future use.
8549        '''
8550        self.rate_limit = rate_limit if rate_limit is not None else None
8551        '''
8552         Rate limit information.
8553        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
8561    def to_dict(self):
8562        return {
8563            'meta': self.meta,
8564            'rate_limit': self.rate_limit,
8565        }
@classmethod
def from_dict(cls, d)
8567    @classmethod
8568    def from_dict(cls, d):
8569        return cls(
8570            meta=d.get('meta'),
8571            rate_limit=d.get('rate_limit'),
8572        )
class NodeGetResponse:
8575class NodeGetResponse:
8576    '''
8577         NodeGetResponse returns a requested Node.
8578    '''
8579    __slots__ = [
8580        'meta',
8581        'node',
8582        'rate_limit',
8583    ]
8584
8585    def __init__(
8586        self,
8587        meta=None,
8588        node=None,
8589        rate_limit=None,
8590    ):
8591        self.meta = meta if meta is not None else None
8592        '''
8593         Reserved for future use.
8594        '''
8595        self.node = node if node is not None else None
8596        '''
8597         The requested Node.
8598        '''
8599        self.rate_limit = rate_limit if rate_limit is not None else None
8600        '''
8601         Rate limit information.
8602        '''
8603
8604    def __repr__(self):
8605        return '<sdm.NodeGetResponse ' + \
8606            'meta: ' + repr(self.meta) + ' ' +\
8607            'node: ' + repr(self.node) + ' ' +\
8608            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8609            '>'
8610
8611    def to_dict(self):
8612        return {
8613            'meta': self.meta,
8614            'node': self.node,
8615            'rate_limit': self.rate_limit,
8616        }
8617
8618    @classmethod
8619    def from_dict(cls, d):
8620        return cls(
8621            meta=d.get('meta'),
8622            node=d.get('node'),
8623            rate_limit=d.get('rate_limit'),
8624        )

NodeGetResponse returns a requested Node.

NodeGetResponse(meta=None, node=None, rate_limit=None)
8585    def __init__(
8586        self,
8587        meta=None,
8588        node=None,
8589        rate_limit=None,
8590    ):
8591        self.meta = meta if meta is not None else None
8592        '''
8593         Reserved for future use.
8594        '''
8595        self.node = node if node is not None else None
8596        '''
8597         The requested Node.
8598        '''
8599        self.rate_limit = rate_limit if rate_limit is not None else None
8600        '''
8601         Rate limit information.
8602        '''
meta

Reserved for future use.

node

The requested Node.

rate_limit

Rate limit information.

def to_dict(self)
8611    def to_dict(self):
8612        return {
8613            'meta': self.meta,
8614            'node': self.node,
8615            'rate_limit': self.rate_limit,
8616        }
@classmethod
def from_dict(cls, d)
8618    @classmethod
8619    def from_dict(cls, d):
8620        return cls(
8621            meta=d.get('meta'),
8622            node=d.get('node'),
8623            rate_limit=d.get('rate_limit'),
8624        )
class NodeUpdateResponse:
8627class NodeUpdateResponse:
8628    '''
8629         NodeUpdateResponse returns the fields of a Node after it has been updated by
8630     a NodeUpdateRequest.
8631    '''
8632    __slots__ = [
8633        'meta',
8634        'node',
8635        'rate_limit',
8636    ]
8637
8638    def __init__(
8639        self,
8640        meta=None,
8641        node=None,
8642        rate_limit=None,
8643    ):
8644        self.meta = meta if meta is not None else None
8645        '''
8646         Reserved for future use.
8647        '''
8648        self.node = node if node is not None else None
8649        '''
8650         The updated Node.
8651        '''
8652        self.rate_limit = rate_limit if rate_limit is not None else None
8653        '''
8654         Rate limit information.
8655        '''
8656
8657    def __repr__(self):
8658        return '<sdm.NodeUpdateResponse ' + \
8659            'meta: ' + repr(self.meta) + ' ' +\
8660            'node: ' + repr(self.node) + ' ' +\
8661            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8662            '>'
8663
8664    def to_dict(self):
8665        return {
8666            'meta': self.meta,
8667            'node': self.node,
8668            'rate_limit': self.rate_limit,
8669        }
8670
8671    @classmethod
8672    def from_dict(cls, d):
8673        return cls(
8674            meta=d.get('meta'),
8675            node=d.get('node'),
8676            rate_limit=d.get('rate_limit'),
8677        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

NodeUpdateResponse(meta=None, node=None, rate_limit=None)
8638    def __init__(
8639        self,
8640        meta=None,
8641        node=None,
8642        rate_limit=None,
8643    ):
8644        self.meta = meta if meta is not None else None
8645        '''
8646         Reserved for future use.
8647        '''
8648        self.node = node if node is not None else None
8649        '''
8650         The updated Node.
8651        '''
8652        self.rate_limit = rate_limit if rate_limit is not None else None
8653        '''
8654         Rate limit information.
8655        '''
meta

Reserved for future use.

node

The updated Node.

rate_limit

Rate limit information.

def to_dict(self)
8664    def to_dict(self):
8665        return {
8666            'meta': self.meta,
8667            'node': self.node,
8668            'rate_limit': self.rate_limit,
8669        }
@classmethod
def from_dict(cls, d)
8671    @classmethod
8672    def from_dict(cls, d):
8673        return cls(
8674            meta=d.get('meta'),
8675            node=d.get('node'),
8676            rate_limit=d.get('rate_limit'),
8677        )
class Oracle:
8680class Oracle:
8681    __slots__ = [
8682        'bind_interface',
8683        'database',
8684        'egress_filter',
8685        'healthy',
8686        'hostname',
8687        'id',
8688        'name',
8689        'password',
8690        'port',
8691        'port_override',
8692        'secret_store_id',
8693        'tags',
8694        'tls_required',
8695        'username',
8696    ]
8697
8698    def __init__(
8699        self,
8700        bind_interface=None,
8701        database=None,
8702        egress_filter=None,
8703        healthy=None,
8704        hostname=None,
8705        id=None,
8706        name=None,
8707        password=None,
8708        port=None,
8709        port_override=None,
8710        secret_store_id=None,
8711        tags=None,
8712        tls_required=None,
8713        username=None,
8714    ):
8715        self.bind_interface = bind_interface if bind_interface is not None else ''
8716        '''
8717         Bind interface
8718        '''
8719        self.database = database if database is not None else ''
8720        self.egress_filter = egress_filter if egress_filter is not None else ''
8721        '''
8722         A filter applied to the routing logic to pin datasource to nodes.
8723        '''
8724        self.healthy = healthy if healthy is not None else False
8725        '''
8726         True if the datasource is reachable and the credentials are valid.
8727        '''
8728        self.hostname = hostname if hostname is not None else ''
8729        self.id = id if id is not None else ''
8730        '''
8731         Unique identifier of the Resource.
8732        '''
8733        self.name = name if name is not None else ''
8734        '''
8735         Unique human-readable name of the Resource.
8736        '''
8737        self.password = password if password is not None else ''
8738        self.port = port if port is not None else 0
8739        self.port_override = port_override if port_override is not None else 0
8740        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8741        '''
8742         ID of the secret store containing credentials for this resource, if any.
8743        '''
8744        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8745        '''
8746         Tags is a map of key, value pairs.
8747        '''
8748        self.tls_required = tls_required if tls_required is not None else False
8749        self.username = username if username is not None else ''
8750
8751    def __repr__(self):
8752        return '<sdm.Oracle ' + \
8753            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8754            'database: ' + repr(self.database) + ' ' +\
8755            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8756            'healthy: ' + repr(self.healthy) + ' ' +\
8757            'hostname: ' + repr(self.hostname) + ' ' +\
8758            'id: ' + repr(self.id) + ' ' +\
8759            'name: ' + repr(self.name) + ' ' +\
8760            'password: ' + repr(self.password) + ' ' +\
8761            'port: ' + repr(self.port) + ' ' +\
8762            'port_override: ' + repr(self.port_override) + ' ' +\
8763            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8764            'tags: ' + repr(self.tags) + ' ' +\
8765            'tls_required: ' + repr(self.tls_required) + ' ' +\
8766            'username: ' + repr(self.username) + ' ' +\
8767            '>'
8768
8769    def to_dict(self):
8770        return {
8771            'bind_interface': self.bind_interface,
8772            'database': self.database,
8773            'egress_filter': self.egress_filter,
8774            'healthy': self.healthy,
8775            'hostname': self.hostname,
8776            'id': self.id,
8777            'name': self.name,
8778            'password': self.password,
8779            'port': self.port,
8780            'port_override': self.port_override,
8781            'secret_store_id': self.secret_store_id,
8782            'tags': self.tags,
8783            'tls_required': self.tls_required,
8784            'username': self.username,
8785        }
8786
8787    @classmethod
8788    def from_dict(cls, d):
8789        return cls(
8790            bind_interface=d.get('bind_interface'),
8791            database=d.get('database'),
8792            egress_filter=d.get('egress_filter'),
8793            healthy=d.get('healthy'),
8794            hostname=d.get('hostname'),
8795            id=d.get('id'),
8796            name=d.get('name'),
8797            password=d.get('password'),
8798            port=d.get('port'),
8799            port_override=d.get('port_override'),
8800            secret_store_id=d.get('secret_store_id'),
8801            tags=d.get('tags'),
8802            tls_required=d.get('tls_required'),
8803            username=d.get('username'),
8804        )
Oracle( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8698    def __init__(
8699        self,
8700        bind_interface=None,
8701        database=None,
8702        egress_filter=None,
8703        healthy=None,
8704        hostname=None,
8705        id=None,
8706        name=None,
8707        password=None,
8708        port=None,
8709        port_override=None,
8710        secret_store_id=None,
8711        tags=None,
8712        tls_required=None,
8713        username=None,
8714    ):
8715        self.bind_interface = bind_interface if bind_interface is not None else ''
8716        '''
8717         Bind interface
8718        '''
8719        self.database = database if database is not None else ''
8720        self.egress_filter = egress_filter if egress_filter is not None else ''
8721        '''
8722         A filter applied to the routing logic to pin datasource to nodes.
8723        '''
8724        self.healthy = healthy if healthy is not None else False
8725        '''
8726         True if the datasource is reachable and the credentials are valid.
8727        '''
8728        self.hostname = hostname if hostname is not None else ''
8729        self.id = id if id is not None else ''
8730        '''
8731         Unique identifier of the Resource.
8732        '''
8733        self.name = name if name is not None else ''
8734        '''
8735         Unique human-readable name of the Resource.
8736        '''
8737        self.password = password if password is not None else ''
8738        self.port = port if port is not None else 0
8739        self.port_override = port_override if port_override is not None else 0
8740        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8741        '''
8742         ID of the secret store containing credentials for this resource, if any.
8743        '''
8744        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8745        '''
8746         Tags is a map of key, value pairs.
8747        '''
8748        self.tls_required = tls_required if tls_required is not None else False
8749        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8769    def to_dict(self):
8770        return {
8771            'bind_interface': self.bind_interface,
8772            'database': self.database,
8773            'egress_filter': self.egress_filter,
8774            'healthy': self.healthy,
8775            'hostname': self.hostname,
8776            'id': self.id,
8777            'name': self.name,
8778            'password': self.password,
8779            'port': self.port,
8780            'port_override': self.port_override,
8781            'secret_store_id': self.secret_store_id,
8782            'tags': self.tags,
8783            'tls_required': self.tls_required,
8784            'username': self.username,
8785        }
@classmethod
def from_dict(cls, d)
8787    @classmethod
8788    def from_dict(cls, d):
8789        return cls(
8790            bind_interface=d.get('bind_interface'),
8791            database=d.get('database'),
8792            egress_filter=d.get('egress_filter'),
8793            healthy=d.get('healthy'),
8794            hostname=d.get('hostname'),
8795            id=d.get('id'),
8796            name=d.get('name'),
8797            password=d.get('password'),
8798            port=d.get('port'),
8799            port_override=d.get('port_override'),
8800            secret_store_id=d.get('secret_store_id'),
8801            tags=d.get('tags'),
8802            tls_required=d.get('tls_required'),
8803            username=d.get('username'),
8804        )
class Postgres:
8807class Postgres:
8808    __slots__ = [
8809        'bind_interface',
8810        'database',
8811        'egress_filter',
8812        'healthy',
8813        'hostname',
8814        'id',
8815        'name',
8816        'override_database',
8817        'password',
8818        'port',
8819        'port_override',
8820        'secret_store_id',
8821        'tags',
8822        'username',
8823    ]
8824
8825    def __init__(
8826        self,
8827        bind_interface=None,
8828        database=None,
8829        egress_filter=None,
8830        healthy=None,
8831        hostname=None,
8832        id=None,
8833        name=None,
8834        override_database=None,
8835        password=None,
8836        port=None,
8837        port_override=None,
8838        secret_store_id=None,
8839        tags=None,
8840        username=None,
8841    ):
8842        self.bind_interface = bind_interface if bind_interface is not None else ''
8843        '''
8844         Bind interface
8845        '''
8846        self.database = database if database is not None else ''
8847        self.egress_filter = egress_filter if egress_filter is not None else ''
8848        '''
8849         A filter applied to the routing logic to pin datasource to nodes.
8850        '''
8851        self.healthy = healthy if healthy is not None else False
8852        '''
8853         True if the datasource is reachable and the credentials are valid.
8854        '''
8855        self.hostname = hostname if hostname is not None else ''
8856        self.id = id if id is not None else ''
8857        '''
8858         Unique identifier of the Resource.
8859        '''
8860        self.name = name if name is not None else ''
8861        '''
8862         Unique human-readable name of the Resource.
8863        '''
8864        self.override_database = override_database if override_database is not None else False
8865        self.password = password if password is not None else ''
8866        self.port = port if port is not None else 0
8867        self.port_override = port_override if port_override is not None else 0
8868        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8869        '''
8870         ID of the secret store containing credentials for this resource, if any.
8871        '''
8872        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8873        '''
8874         Tags is a map of key, value pairs.
8875        '''
8876        self.username = username if username is not None else ''
8877
8878    def __repr__(self):
8879        return '<sdm.Postgres ' + \
8880            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8881            'database: ' + repr(self.database) + ' ' +\
8882            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8883            'healthy: ' + repr(self.healthy) + ' ' +\
8884            'hostname: ' + repr(self.hostname) + ' ' +\
8885            'id: ' + repr(self.id) + ' ' +\
8886            'name: ' + repr(self.name) + ' ' +\
8887            'override_database: ' + repr(self.override_database) + ' ' +\
8888            'password: ' + repr(self.password) + ' ' +\
8889            'port: ' + repr(self.port) + ' ' +\
8890            'port_override: ' + repr(self.port_override) + ' ' +\
8891            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8892            'tags: ' + repr(self.tags) + ' ' +\
8893            'username: ' + repr(self.username) + ' ' +\
8894            '>'
8895
8896    def to_dict(self):
8897        return {
8898            'bind_interface': self.bind_interface,
8899            'database': self.database,
8900            'egress_filter': self.egress_filter,
8901            'healthy': self.healthy,
8902            'hostname': self.hostname,
8903            'id': self.id,
8904            'name': self.name,
8905            'override_database': self.override_database,
8906            'password': self.password,
8907            'port': self.port,
8908            'port_override': self.port_override,
8909            'secret_store_id': self.secret_store_id,
8910            'tags': self.tags,
8911            'username': self.username,
8912        }
8913
8914    @classmethod
8915    def from_dict(cls, d):
8916        return cls(
8917            bind_interface=d.get('bind_interface'),
8918            database=d.get('database'),
8919            egress_filter=d.get('egress_filter'),
8920            healthy=d.get('healthy'),
8921            hostname=d.get('hostname'),
8922            id=d.get('id'),
8923            name=d.get('name'),
8924            override_database=d.get('override_database'),
8925            password=d.get('password'),
8926            port=d.get('port'),
8927            port_override=d.get('port_override'),
8928            secret_store_id=d.get('secret_store_id'),
8929            tags=d.get('tags'),
8930            username=d.get('username'),
8931        )
Postgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8825    def __init__(
8826        self,
8827        bind_interface=None,
8828        database=None,
8829        egress_filter=None,
8830        healthy=None,
8831        hostname=None,
8832        id=None,
8833        name=None,
8834        override_database=None,
8835        password=None,
8836        port=None,
8837        port_override=None,
8838        secret_store_id=None,
8839        tags=None,
8840        username=None,
8841    ):
8842        self.bind_interface = bind_interface if bind_interface is not None else ''
8843        '''
8844         Bind interface
8845        '''
8846        self.database = database if database is not None else ''
8847        self.egress_filter = egress_filter if egress_filter is not None else ''
8848        '''
8849         A filter applied to the routing logic to pin datasource to nodes.
8850        '''
8851        self.healthy = healthy if healthy is not None else False
8852        '''
8853         True if the datasource is reachable and the credentials are valid.
8854        '''
8855        self.hostname = hostname if hostname is not None else ''
8856        self.id = id if id is not None else ''
8857        '''
8858         Unique identifier of the Resource.
8859        '''
8860        self.name = name if name is not None else ''
8861        '''
8862         Unique human-readable name of the Resource.
8863        '''
8864        self.override_database = override_database if override_database is not None else False
8865        self.password = password if password is not None else ''
8866        self.port = port if port is not None else 0
8867        self.port_override = port_override if port_override is not None else 0
8868        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8869        '''
8870         ID of the secret store containing credentials for this resource, if any.
8871        '''
8872        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8873        '''
8874         Tags is a map of key, value pairs.
8875        '''
8876        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8896    def to_dict(self):
8897        return {
8898            'bind_interface': self.bind_interface,
8899            'database': self.database,
8900            'egress_filter': self.egress_filter,
8901            'healthy': self.healthy,
8902            'hostname': self.hostname,
8903            'id': self.id,
8904            'name': self.name,
8905            'override_database': self.override_database,
8906            'password': self.password,
8907            'port': self.port,
8908            'port_override': self.port_override,
8909            'secret_store_id': self.secret_store_id,
8910            'tags': self.tags,
8911            'username': self.username,
8912        }
@classmethod
def from_dict(cls, d)
8914    @classmethod
8915    def from_dict(cls, d):
8916        return cls(
8917            bind_interface=d.get('bind_interface'),
8918            database=d.get('database'),
8919            egress_filter=d.get('egress_filter'),
8920            healthy=d.get('healthy'),
8921            hostname=d.get('hostname'),
8922            id=d.get('id'),
8923            name=d.get('name'),
8924            override_database=d.get('override_database'),
8925            password=d.get('password'),
8926            port=d.get('port'),
8927            port_override=d.get('port_override'),
8928            secret_store_id=d.get('secret_store_id'),
8929            tags=d.get('tags'),
8930            username=d.get('username'),
8931        )
class Presto:
8934class Presto:
8935    __slots__ = [
8936        'bind_interface',
8937        'database',
8938        'egress_filter',
8939        'healthy',
8940        'hostname',
8941        'id',
8942        'name',
8943        'password',
8944        'port',
8945        'port_override',
8946        'secret_store_id',
8947        'tags',
8948        'tls_required',
8949        'username',
8950    ]
8951
8952    def __init__(
8953        self,
8954        bind_interface=None,
8955        database=None,
8956        egress_filter=None,
8957        healthy=None,
8958        hostname=None,
8959        id=None,
8960        name=None,
8961        password=None,
8962        port=None,
8963        port_override=None,
8964        secret_store_id=None,
8965        tags=None,
8966        tls_required=None,
8967        username=None,
8968    ):
8969        self.bind_interface = bind_interface if bind_interface is not None else ''
8970        '''
8971         Bind interface
8972        '''
8973        self.database = database if database is not None else ''
8974        self.egress_filter = egress_filter if egress_filter is not None else ''
8975        '''
8976         A filter applied to the routing logic to pin datasource to nodes.
8977        '''
8978        self.healthy = healthy if healthy is not None else False
8979        '''
8980         True if the datasource is reachable and the credentials are valid.
8981        '''
8982        self.hostname = hostname if hostname is not None else ''
8983        self.id = id if id is not None else ''
8984        '''
8985         Unique identifier of the Resource.
8986        '''
8987        self.name = name if name is not None else ''
8988        '''
8989         Unique human-readable name of the Resource.
8990        '''
8991        self.password = password if password is not None else ''
8992        self.port = port if port is not None else 0
8993        self.port_override = port_override if port_override is not None else 0
8994        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8995        '''
8996         ID of the secret store containing credentials for this resource, if any.
8997        '''
8998        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8999        '''
9000         Tags is a map of key, value pairs.
9001        '''
9002        self.tls_required = tls_required if tls_required is not None else False
9003        self.username = username if username is not None else ''
9004
9005    def __repr__(self):
9006        return '<sdm.Presto ' + \
9007            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9008            'database: ' + repr(self.database) + ' ' +\
9009            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9010            'healthy: ' + repr(self.healthy) + ' ' +\
9011            'hostname: ' + repr(self.hostname) + ' ' +\
9012            'id: ' + repr(self.id) + ' ' +\
9013            'name: ' + repr(self.name) + ' ' +\
9014            'password: ' + repr(self.password) + ' ' +\
9015            'port: ' + repr(self.port) + ' ' +\
9016            'port_override: ' + repr(self.port_override) + ' ' +\
9017            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9018            'tags: ' + repr(self.tags) + ' ' +\
9019            'tls_required: ' + repr(self.tls_required) + ' ' +\
9020            'username: ' + repr(self.username) + ' ' +\
9021            '>'
9022
9023    def to_dict(self):
9024        return {
9025            'bind_interface': self.bind_interface,
9026            'database': self.database,
9027            'egress_filter': self.egress_filter,
9028            'healthy': self.healthy,
9029            'hostname': self.hostname,
9030            'id': self.id,
9031            'name': self.name,
9032            'password': self.password,
9033            'port': self.port,
9034            'port_override': self.port_override,
9035            'secret_store_id': self.secret_store_id,
9036            'tags': self.tags,
9037            'tls_required': self.tls_required,
9038            'username': self.username,
9039        }
9040
9041    @classmethod
9042    def from_dict(cls, d):
9043        return cls(
9044            bind_interface=d.get('bind_interface'),
9045            database=d.get('database'),
9046            egress_filter=d.get('egress_filter'),
9047            healthy=d.get('healthy'),
9048            hostname=d.get('hostname'),
9049            id=d.get('id'),
9050            name=d.get('name'),
9051            password=d.get('password'),
9052            port=d.get('port'),
9053            port_override=d.get('port_override'),
9054            secret_store_id=d.get('secret_store_id'),
9055            tags=d.get('tags'),
9056            tls_required=d.get('tls_required'),
9057            username=d.get('username'),
9058        )
Presto( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8952    def __init__(
8953        self,
8954        bind_interface=None,
8955        database=None,
8956        egress_filter=None,
8957        healthy=None,
8958        hostname=None,
8959        id=None,
8960        name=None,
8961        password=None,
8962        port=None,
8963        port_override=None,
8964        secret_store_id=None,
8965        tags=None,
8966        tls_required=None,
8967        username=None,
8968    ):
8969        self.bind_interface = bind_interface if bind_interface is not None else ''
8970        '''
8971         Bind interface
8972        '''
8973        self.database = database if database is not None else ''
8974        self.egress_filter = egress_filter if egress_filter is not None else ''
8975        '''
8976         A filter applied to the routing logic to pin datasource to nodes.
8977        '''
8978        self.healthy = healthy if healthy is not None else False
8979        '''
8980         True if the datasource is reachable and the credentials are valid.
8981        '''
8982        self.hostname = hostname if hostname is not None else ''
8983        self.id = id if id is not None else ''
8984        '''
8985         Unique identifier of the Resource.
8986        '''
8987        self.name = name if name is not None else ''
8988        '''
8989         Unique human-readable name of the Resource.
8990        '''
8991        self.password = password if password is not None else ''
8992        self.port = port if port is not None else 0
8993        self.port_override = port_override if port_override is not None else 0
8994        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8995        '''
8996         ID of the secret store containing credentials for this resource, if any.
8997        '''
8998        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8999        '''
9000         Tags is a map of key, value pairs.
9001        '''
9002        self.tls_required = tls_required if tls_required is not None else False
9003        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9023    def to_dict(self):
9024        return {
9025            'bind_interface': self.bind_interface,
9026            'database': self.database,
9027            'egress_filter': self.egress_filter,
9028            'healthy': self.healthy,
9029            'hostname': self.hostname,
9030            'id': self.id,
9031            'name': self.name,
9032            'password': self.password,
9033            'port': self.port,
9034            'port_override': self.port_override,
9035            'secret_store_id': self.secret_store_id,
9036            'tags': self.tags,
9037            'tls_required': self.tls_required,
9038            'username': self.username,
9039        }
@classmethod
def from_dict(cls, d)
9041    @classmethod
9042    def from_dict(cls, d):
9043        return cls(
9044            bind_interface=d.get('bind_interface'),
9045            database=d.get('database'),
9046            egress_filter=d.get('egress_filter'),
9047            healthy=d.get('healthy'),
9048            hostname=d.get('hostname'),
9049            id=d.get('id'),
9050            name=d.get('name'),
9051            password=d.get('password'),
9052            port=d.get('port'),
9053            port_override=d.get('port_override'),
9054            secret_store_id=d.get('secret_store_id'),
9055            tags=d.get('tags'),
9056            tls_required=d.get('tls_required'),
9057            username=d.get('username'),
9058        )
class RDP:
9061class RDP:
9062    __slots__ = [
9063        'bind_interface',
9064        'downgrade_nla_connections',
9065        'egress_filter',
9066        'healthy',
9067        'hostname',
9068        'id',
9069        'name',
9070        'password',
9071        'port',
9072        'port_override',
9073        'secret_store_id',
9074        'tags',
9075        'username',
9076    ]
9077
9078    def __init__(
9079        self,
9080        bind_interface=None,
9081        downgrade_nla_connections=None,
9082        egress_filter=None,
9083        healthy=None,
9084        hostname=None,
9085        id=None,
9086        name=None,
9087        password=None,
9088        port=None,
9089        port_override=None,
9090        secret_store_id=None,
9091        tags=None,
9092        username=None,
9093    ):
9094        self.bind_interface = bind_interface if bind_interface is not None else ''
9095        '''
9096         Bind interface
9097        '''
9098        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9099        self.egress_filter = egress_filter if egress_filter is not None else ''
9100        '''
9101         A filter applied to the routing logic to pin datasource to nodes.
9102        '''
9103        self.healthy = healthy if healthy is not None else False
9104        '''
9105         True if the datasource is reachable and the credentials are valid.
9106        '''
9107        self.hostname = hostname if hostname is not None else ''
9108        self.id = id if id is not None else ''
9109        '''
9110         Unique identifier of the Resource.
9111        '''
9112        self.name = name if name is not None else ''
9113        '''
9114         Unique human-readable name of the Resource.
9115        '''
9116        self.password = password if password is not None else ''
9117        self.port = port if port is not None else 0
9118        self.port_override = port_override if port_override is not None else 0
9119        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9120        '''
9121         ID of the secret store containing credentials for this resource, if any.
9122        '''
9123        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9124        '''
9125         Tags is a map of key, value pairs.
9126        '''
9127        self.username = username if username is not None else ''
9128
9129    def __repr__(self):
9130        return '<sdm.RDP ' + \
9131            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9132            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
9133            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9134            'healthy: ' + repr(self.healthy) + ' ' +\
9135            'hostname: ' + repr(self.hostname) + ' ' +\
9136            'id: ' + repr(self.id) + ' ' +\
9137            'name: ' + repr(self.name) + ' ' +\
9138            'password: ' + repr(self.password) + ' ' +\
9139            'port: ' + repr(self.port) + ' ' +\
9140            'port_override: ' + repr(self.port_override) + ' ' +\
9141            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9142            'tags: ' + repr(self.tags) + ' ' +\
9143            'username: ' + repr(self.username) + ' ' +\
9144            '>'
9145
9146    def to_dict(self):
9147        return {
9148            'bind_interface': self.bind_interface,
9149            'downgrade_nla_connections': self.downgrade_nla_connections,
9150            'egress_filter': self.egress_filter,
9151            'healthy': self.healthy,
9152            'hostname': self.hostname,
9153            'id': self.id,
9154            'name': self.name,
9155            'password': self.password,
9156            'port': self.port,
9157            'port_override': self.port_override,
9158            'secret_store_id': self.secret_store_id,
9159            'tags': self.tags,
9160            'username': self.username,
9161        }
9162
9163    @classmethod
9164    def from_dict(cls, d):
9165        return cls(
9166            bind_interface=d.get('bind_interface'),
9167            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9168            egress_filter=d.get('egress_filter'),
9169            healthy=d.get('healthy'),
9170            hostname=d.get('hostname'),
9171            id=d.get('id'),
9172            name=d.get('name'),
9173            password=d.get('password'),
9174            port=d.get('port'),
9175            port_override=d.get('port_override'),
9176            secret_store_id=d.get('secret_store_id'),
9177            tags=d.get('tags'),
9178            username=d.get('username'),
9179        )
RDP( bind_interface=None, downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9078    def __init__(
9079        self,
9080        bind_interface=None,
9081        downgrade_nla_connections=None,
9082        egress_filter=None,
9083        healthy=None,
9084        hostname=None,
9085        id=None,
9086        name=None,
9087        password=None,
9088        port=None,
9089        port_override=None,
9090        secret_store_id=None,
9091        tags=None,
9092        username=None,
9093    ):
9094        self.bind_interface = bind_interface if bind_interface is not None else ''
9095        '''
9096         Bind interface
9097        '''
9098        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9099        self.egress_filter = egress_filter if egress_filter is not None else ''
9100        '''
9101         A filter applied to the routing logic to pin datasource to nodes.
9102        '''
9103        self.healthy = healthy if healthy is not None else False
9104        '''
9105         True if the datasource is reachable and the credentials are valid.
9106        '''
9107        self.hostname = hostname if hostname is not None else ''
9108        self.id = id if id is not None else ''
9109        '''
9110         Unique identifier of the Resource.
9111        '''
9112        self.name = name if name is not None else ''
9113        '''
9114         Unique human-readable name of the Resource.
9115        '''
9116        self.password = password if password is not None else ''
9117        self.port = port if port is not None else 0
9118        self.port_override = port_override if port_override is not None else 0
9119        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9120        '''
9121         ID of the secret store containing credentials for this resource, if any.
9122        '''
9123        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9124        '''
9125         Tags is a map of key, value pairs.
9126        '''
9127        self.username = username if username is not None else ''
bind_interface

Bind interface

downgrade_nla_connections
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9146    def to_dict(self):
9147        return {
9148            'bind_interface': self.bind_interface,
9149            'downgrade_nla_connections': self.downgrade_nla_connections,
9150            'egress_filter': self.egress_filter,
9151            'healthy': self.healthy,
9152            'hostname': self.hostname,
9153            'id': self.id,
9154            'name': self.name,
9155            'password': self.password,
9156            'port': self.port,
9157            'port_override': self.port_override,
9158            'secret_store_id': self.secret_store_id,
9159            'tags': self.tags,
9160            'username': self.username,
9161        }
@classmethod
def from_dict(cls, d)
9163    @classmethod
9164    def from_dict(cls, d):
9165        return cls(
9166            bind_interface=d.get('bind_interface'),
9167            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9168            egress_filter=d.get('egress_filter'),
9169            healthy=d.get('healthy'),
9170            hostname=d.get('hostname'),
9171            id=d.get('id'),
9172            name=d.get('name'),
9173            password=d.get('password'),
9174            port=d.get('port'),
9175            port_override=d.get('port_override'),
9176            secret_store_id=d.get('secret_store_id'),
9177            tags=d.get('tags'),
9178            username=d.get('username'),
9179        )
class RabbitMQAMQP091:
9182class RabbitMQAMQP091:
9183    __slots__ = [
9184        'bind_interface',
9185        'egress_filter',
9186        'healthy',
9187        'hostname',
9188        'id',
9189        'name',
9190        'password',
9191        'port',
9192        'port_override',
9193        'secret_store_id',
9194        'tags',
9195        'tls_required',
9196        'username',
9197    ]
9198
9199    def __init__(
9200        self,
9201        bind_interface=None,
9202        egress_filter=None,
9203        healthy=None,
9204        hostname=None,
9205        id=None,
9206        name=None,
9207        password=None,
9208        port=None,
9209        port_override=None,
9210        secret_store_id=None,
9211        tags=None,
9212        tls_required=None,
9213        username=None,
9214    ):
9215        self.bind_interface = bind_interface if bind_interface is not None else ''
9216        '''
9217         Bind interface
9218        '''
9219        self.egress_filter = egress_filter if egress_filter is not None else ''
9220        '''
9221         A filter applied to the routing logic to pin datasource to nodes.
9222        '''
9223        self.healthy = healthy if healthy is not None else False
9224        '''
9225         True if the datasource is reachable and the credentials are valid.
9226        '''
9227        self.hostname = hostname if hostname is not None else ''
9228        self.id = id if id is not None else ''
9229        '''
9230         Unique identifier of the Resource.
9231        '''
9232        self.name = name if name is not None else ''
9233        '''
9234         Unique human-readable name of the Resource.
9235        '''
9236        self.password = password if password is not None else ''
9237        self.port = port if port is not None else 0
9238        self.port_override = port_override if port_override is not None else 0
9239        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9240        '''
9241         ID of the secret store containing credentials for this resource, if any.
9242        '''
9243        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9244        '''
9245         Tags is a map of key, value pairs.
9246        '''
9247        self.tls_required = tls_required if tls_required is not None else False
9248        self.username = username if username is not None else ''
9249
9250    def __repr__(self):
9251        return '<sdm.RabbitMQAMQP091 ' + \
9252            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9253            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9254            'healthy: ' + repr(self.healthy) + ' ' +\
9255            'hostname: ' + repr(self.hostname) + ' ' +\
9256            'id: ' + repr(self.id) + ' ' +\
9257            'name: ' + repr(self.name) + ' ' +\
9258            'password: ' + repr(self.password) + ' ' +\
9259            'port: ' + repr(self.port) + ' ' +\
9260            'port_override: ' + repr(self.port_override) + ' ' +\
9261            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9262            'tags: ' + repr(self.tags) + ' ' +\
9263            'tls_required: ' + repr(self.tls_required) + ' ' +\
9264            'username: ' + repr(self.username) + ' ' +\
9265            '>'
9266
9267    def to_dict(self):
9268        return {
9269            'bind_interface': self.bind_interface,
9270            'egress_filter': self.egress_filter,
9271            'healthy': self.healthy,
9272            'hostname': self.hostname,
9273            'id': self.id,
9274            'name': self.name,
9275            'password': self.password,
9276            'port': self.port,
9277            'port_override': self.port_override,
9278            'secret_store_id': self.secret_store_id,
9279            'tags': self.tags,
9280            'tls_required': self.tls_required,
9281            'username': self.username,
9282        }
9283
9284    @classmethod
9285    def from_dict(cls, d):
9286        return cls(
9287            bind_interface=d.get('bind_interface'),
9288            egress_filter=d.get('egress_filter'),
9289            healthy=d.get('healthy'),
9290            hostname=d.get('hostname'),
9291            id=d.get('id'),
9292            name=d.get('name'),
9293            password=d.get('password'),
9294            port=d.get('port'),
9295            port_override=d.get('port_override'),
9296            secret_store_id=d.get('secret_store_id'),
9297            tags=d.get('tags'),
9298            tls_required=d.get('tls_required'),
9299            username=d.get('username'),
9300        )
RabbitMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9199    def __init__(
9200        self,
9201        bind_interface=None,
9202        egress_filter=None,
9203        healthy=None,
9204        hostname=None,
9205        id=None,
9206        name=None,
9207        password=None,
9208        port=None,
9209        port_override=None,
9210        secret_store_id=None,
9211        tags=None,
9212        tls_required=None,
9213        username=None,
9214    ):
9215        self.bind_interface = bind_interface if bind_interface is not None else ''
9216        '''
9217         Bind interface
9218        '''
9219        self.egress_filter = egress_filter if egress_filter is not None else ''
9220        '''
9221         A filter applied to the routing logic to pin datasource to nodes.
9222        '''
9223        self.healthy = healthy if healthy is not None else False
9224        '''
9225         True if the datasource is reachable and the credentials are valid.
9226        '''
9227        self.hostname = hostname if hostname is not None else ''
9228        self.id = id if id is not None else ''
9229        '''
9230         Unique identifier of the Resource.
9231        '''
9232        self.name = name if name is not None else ''
9233        '''
9234         Unique human-readable name of the Resource.
9235        '''
9236        self.password = password if password is not None else ''
9237        self.port = port if port is not None else 0
9238        self.port_override = port_override if port_override is not None else 0
9239        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9240        '''
9241         ID of the secret store containing credentials for this resource, if any.
9242        '''
9243        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9244        '''
9245         Tags is a map of key, value pairs.
9246        '''
9247        self.tls_required = tls_required if tls_required is not None else False
9248        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9267    def to_dict(self):
9268        return {
9269            'bind_interface': self.bind_interface,
9270            'egress_filter': self.egress_filter,
9271            'healthy': self.healthy,
9272            'hostname': self.hostname,
9273            'id': self.id,
9274            'name': self.name,
9275            'password': self.password,
9276            'port': self.port,
9277            'port_override': self.port_override,
9278            'secret_store_id': self.secret_store_id,
9279            'tags': self.tags,
9280            'tls_required': self.tls_required,
9281            'username': self.username,
9282        }
@classmethod
def from_dict(cls, d)
9284    @classmethod
9285    def from_dict(cls, d):
9286        return cls(
9287            bind_interface=d.get('bind_interface'),
9288            egress_filter=d.get('egress_filter'),
9289            healthy=d.get('healthy'),
9290            hostname=d.get('hostname'),
9291            id=d.get('id'),
9292            name=d.get('name'),
9293            password=d.get('password'),
9294            port=d.get('port'),
9295            port_override=d.get('port_override'),
9296            secret_store_id=d.get('secret_store_id'),
9297            tags=d.get('tags'),
9298            tls_required=d.get('tls_required'),
9299            username=d.get('username'),
9300        )
class RateLimitMetadata:
9303class RateLimitMetadata:
9304    '''
9305         RateLimitMetadata contains information about remaining requests avaialable
9306     to the user over some timeframe.
9307    '''
9308    __slots__ = [
9309        'bucket',
9310        'limit',
9311        'remaining',
9312        'reset_at',
9313    ]
9314
9315    def __init__(
9316        self,
9317        bucket=None,
9318        limit=None,
9319        remaining=None,
9320        reset_at=None,
9321    ):
9322        self.bucket = bucket if bucket is not None else ''
9323        '''
9324         The bucket this user/token is associated with, which may be shared between
9325         multiple users/tokens.
9326        '''
9327        self.limit = limit if limit is not None else 0
9328        '''
9329         How many total requests the user/token is authorized to make before being
9330         rate limited.
9331        '''
9332        self.remaining = remaining if remaining is not None else 0
9333        '''
9334         How many remaining requests out of the limit are still avaialable.
9335        '''
9336        self.reset_at = reset_at if reset_at is not None else None
9337        '''
9338         The time when remaining will be reset to limit.
9339        '''
9340
9341    def __repr__(self):
9342        return '<sdm.RateLimitMetadata ' + \
9343            'bucket: ' + repr(self.bucket) + ' ' +\
9344            'limit: ' + repr(self.limit) + ' ' +\
9345            'remaining: ' + repr(self.remaining) + ' ' +\
9346            'reset_at: ' + repr(self.reset_at) + ' ' +\
9347            '>'
9348
9349    def to_dict(self):
9350        return {
9351            'bucket': self.bucket,
9352            'limit': self.limit,
9353            'remaining': self.remaining,
9354            'reset_at': self.reset_at,
9355        }
9356
9357    @classmethod
9358    def from_dict(cls, d):
9359        return cls(
9360            bucket=d.get('bucket'),
9361            limit=d.get('limit'),
9362            remaining=d.get('remaining'),
9363            reset_at=d.get('reset_at'),
9364        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
9315    def __init__(
9316        self,
9317        bucket=None,
9318        limit=None,
9319        remaining=None,
9320        reset_at=None,
9321    ):
9322        self.bucket = bucket if bucket is not None else ''
9323        '''
9324         The bucket this user/token is associated with, which may be shared between
9325         multiple users/tokens.
9326        '''
9327        self.limit = limit if limit is not None else 0
9328        '''
9329         How many total requests the user/token is authorized to make before being
9330         rate limited.
9331        '''
9332        self.remaining = remaining if remaining is not None else 0
9333        '''
9334         How many remaining requests out of the limit are still avaialable.
9335        '''
9336        self.reset_at = reset_at if reset_at is not None else None
9337        '''
9338         The time when remaining will be reset to limit.
9339        '''
bucket

The bucket this user/token is associated with, which may be shared between multiple users/tokens.

limit

How many total requests the user/token is authorized to make before being rate limited.

remaining

How many remaining requests out of the limit are still avaialable.

reset_at

The time when remaining will be reset to limit.

def to_dict(self)
9349    def to_dict(self):
9350        return {
9351            'bucket': self.bucket,
9352            'limit': self.limit,
9353            'remaining': self.remaining,
9354            'reset_at': self.reset_at,
9355        }
@classmethod
def from_dict(cls, d)
9357    @classmethod
9358    def from_dict(cls, d):
9359        return cls(
9360            bucket=d.get('bucket'),
9361            limit=d.get('limit'),
9362            remaining=d.get('remaining'),
9363            reset_at=d.get('reset_at'),
9364        )
class RawTCP:
9367class RawTCP:
9368    __slots__ = [
9369        'bind_interface',
9370        'egress_filter',
9371        'healthy',
9372        'hostname',
9373        'id',
9374        'name',
9375        'port',
9376        'port_override',
9377        'secret_store_id',
9378        'tags',
9379    ]
9380
9381    def __init__(
9382        self,
9383        bind_interface=None,
9384        egress_filter=None,
9385        healthy=None,
9386        hostname=None,
9387        id=None,
9388        name=None,
9389        port=None,
9390        port_override=None,
9391        secret_store_id=None,
9392        tags=None,
9393    ):
9394        self.bind_interface = bind_interface if bind_interface is not None else ''
9395        '''
9396         Bind interface
9397        '''
9398        self.egress_filter = egress_filter if egress_filter is not None else ''
9399        '''
9400         A filter applied to the routing logic to pin datasource to nodes.
9401        '''
9402        self.healthy = healthy if healthy is not None else False
9403        '''
9404         True if the datasource is reachable and the credentials are valid.
9405        '''
9406        self.hostname = hostname if hostname is not None else ''
9407        self.id = id if id is not None else ''
9408        '''
9409         Unique identifier of the Resource.
9410        '''
9411        self.name = name if name is not None else ''
9412        '''
9413         Unique human-readable name of the Resource.
9414        '''
9415        self.port = port if port is not None else 0
9416        self.port_override = port_override if port_override is not None else 0
9417        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9418        '''
9419         ID of the secret store containing credentials for this resource, if any.
9420        '''
9421        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9422        '''
9423         Tags is a map of key, value pairs.
9424        '''
9425
9426    def __repr__(self):
9427        return '<sdm.RawTCP ' + \
9428            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9429            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9430            'healthy: ' + repr(self.healthy) + ' ' +\
9431            'hostname: ' + repr(self.hostname) + ' ' +\
9432            'id: ' + repr(self.id) + ' ' +\
9433            'name: ' + repr(self.name) + ' ' +\
9434            'port: ' + repr(self.port) + ' ' +\
9435            'port_override: ' + repr(self.port_override) + ' ' +\
9436            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9437            'tags: ' + repr(self.tags) + ' ' +\
9438            '>'
9439
9440    def to_dict(self):
9441        return {
9442            'bind_interface': self.bind_interface,
9443            'egress_filter': self.egress_filter,
9444            'healthy': self.healthy,
9445            'hostname': self.hostname,
9446            'id': self.id,
9447            'name': self.name,
9448            'port': self.port,
9449            'port_override': self.port_override,
9450            'secret_store_id': self.secret_store_id,
9451            'tags': self.tags,
9452        }
9453
9454    @classmethod
9455    def from_dict(cls, d):
9456        return cls(
9457            bind_interface=d.get('bind_interface'),
9458            egress_filter=d.get('egress_filter'),
9459            healthy=d.get('healthy'),
9460            hostname=d.get('hostname'),
9461            id=d.get('id'),
9462            name=d.get('name'),
9463            port=d.get('port'),
9464            port_override=d.get('port_override'),
9465            secret_store_id=d.get('secret_store_id'),
9466            tags=d.get('tags'),
9467        )
RawTCP( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
9381    def __init__(
9382        self,
9383        bind_interface=None,
9384        egress_filter=None,
9385        healthy=None,
9386        hostname=None,
9387        id=None,
9388        name=None,
9389        port=None,
9390        port_override=None,
9391        secret_store_id=None,
9392        tags=None,
9393    ):
9394        self.bind_interface = bind_interface if bind_interface is not None else ''
9395        '''
9396         Bind interface
9397        '''
9398        self.egress_filter = egress_filter if egress_filter is not None else ''
9399        '''
9400         A filter applied to the routing logic to pin datasource to nodes.
9401        '''
9402        self.healthy = healthy if healthy is not None else False
9403        '''
9404         True if the datasource is reachable and the credentials are valid.
9405        '''
9406        self.hostname = hostname if hostname is not None else ''
9407        self.id = id if id is not None else ''
9408        '''
9409         Unique identifier of the Resource.
9410        '''
9411        self.name = name if name is not None else ''
9412        '''
9413         Unique human-readable name of the Resource.
9414        '''
9415        self.port = port if port is not None else 0
9416        self.port_override = port_override if port_override is not None else 0
9417        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9418        '''
9419         ID of the secret store containing credentials for this resource, if any.
9420        '''
9421        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9422        '''
9423         Tags is a map of key, value pairs.
9424        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9440    def to_dict(self):
9441        return {
9442            'bind_interface': self.bind_interface,
9443            'egress_filter': self.egress_filter,
9444            'healthy': self.healthy,
9445            'hostname': self.hostname,
9446            'id': self.id,
9447            'name': self.name,
9448            'port': self.port,
9449            'port_override': self.port_override,
9450            'secret_store_id': self.secret_store_id,
9451            'tags': self.tags,
9452        }
@classmethod
def from_dict(cls, d)
9454    @classmethod
9455    def from_dict(cls, d):
9456        return cls(
9457            bind_interface=d.get('bind_interface'),
9458            egress_filter=d.get('egress_filter'),
9459            healthy=d.get('healthy'),
9460            hostname=d.get('hostname'),
9461            id=d.get('id'),
9462            name=d.get('name'),
9463            port=d.get('port'),
9464            port_override=d.get('port_override'),
9465            secret_store_id=d.get('secret_store_id'),
9466            tags=d.get('tags'),
9467        )
class Redis:
9470class Redis:
9471    __slots__ = [
9472        'bind_interface',
9473        'egress_filter',
9474        'healthy',
9475        'hostname',
9476        'id',
9477        'name',
9478        'password',
9479        'port',
9480        'port_override',
9481        'secret_store_id',
9482        'tags',
9483    ]
9484
9485    def __init__(
9486        self,
9487        bind_interface=None,
9488        egress_filter=None,
9489        healthy=None,
9490        hostname=None,
9491        id=None,
9492        name=None,
9493        password=None,
9494        port=None,
9495        port_override=None,
9496        secret_store_id=None,
9497        tags=None,
9498    ):
9499        self.bind_interface = bind_interface if bind_interface is not None else ''
9500        '''
9501         Bind interface
9502        '''
9503        self.egress_filter = egress_filter if egress_filter is not None else ''
9504        '''
9505         A filter applied to the routing logic to pin datasource to nodes.
9506        '''
9507        self.healthy = healthy if healthy is not None else False
9508        '''
9509         True if the datasource is reachable and the credentials are valid.
9510        '''
9511        self.hostname = hostname if hostname is not None else ''
9512        self.id = id if id is not None else ''
9513        '''
9514         Unique identifier of the Resource.
9515        '''
9516        self.name = name if name is not None else ''
9517        '''
9518         Unique human-readable name of the Resource.
9519        '''
9520        self.password = password if password is not None else ''
9521        self.port = port if port is not None else 0
9522        self.port_override = port_override if port_override is not None else 0
9523        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9524        '''
9525         ID of the secret store containing credentials for this resource, if any.
9526        '''
9527        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9528        '''
9529         Tags is a map of key, value pairs.
9530        '''
9531
9532    def __repr__(self):
9533        return '<sdm.Redis ' + \
9534            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9535            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9536            'healthy: ' + repr(self.healthy) + ' ' +\
9537            'hostname: ' + repr(self.hostname) + ' ' +\
9538            'id: ' + repr(self.id) + ' ' +\
9539            'name: ' + repr(self.name) + ' ' +\
9540            'password: ' + repr(self.password) + ' ' +\
9541            'port: ' + repr(self.port) + ' ' +\
9542            'port_override: ' + repr(self.port_override) + ' ' +\
9543            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9544            'tags: ' + repr(self.tags) + ' ' +\
9545            '>'
9546
9547    def to_dict(self):
9548        return {
9549            'bind_interface': self.bind_interface,
9550            'egress_filter': self.egress_filter,
9551            'healthy': self.healthy,
9552            'hostname': self.hostname,
9553            'id': self.id,
9554            'name': self.name,
9555            'password': self.password,
9556            'port': self.port,
9557            'port_override': self.port_override,
9558            'secret_store_id': self.secret_store_id,
9559            'tags': self.tags,
9560        }
9561
9562    @classmethod
9563    def from_dict(cls, d):
9564        return cls(
9565            bind_interface=d.get('bind_interface'),
9566            egress_filter=d.get('egress_filter'),
9567            healthy=d.get('healthy'),
9568            hostname=d.get('hostname'),
9569            id=d.get('id'),
9570            name=d.get('name'),
9571            password=d.get('password'),
9572            port=d.get('port'),
9573            port_override=d.get('port_override'),
9574            secret_store_id=d.get('secret_store_id'),
9575            tags=d.get('tags'),
9576        )
Redis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None)
9485    def __init__(
9486        self,
9487        bind_interface=None,
9488        egress_filter=None,
9489        healthy=None,
9490        hostname=None,
9491        id=None,
9492        name=None,
9493        password=None,
9494        port=None,
9495        port_override=None,
9496        secret_store_id=None,
9497        tags=None,
9498    ):
9499        self.bind_interface = bind_interface if bind_interface is not None else ''
9500        '''
9501         Bind interface
9502        '''
9503        self.egress_filter = egress_filter if egress_filter is not None else ''
9504        '''
9505         A filter applied to the routing logic to pin datasource to nodes.
9506        '''
9507        self.healthy = healthy if healthy is not None else False
9508        '''
9509         True if the datasource is reachable and the credentials are valid.
9510        '''
9511        self.hostname = hostname if hostname is not None else ''
9512        self.id = id if id is not None else ''
9513        '''
9514         Unique identifier of the Resource.
9515        '''
9516        self.name = name if name is not None else ''
9517        '''
9518         Unique human-readable name of the Resource.
9519        '''
9520        self.password = password if password is not None else ''
9521        self.port = port if port is not None else 0
9522        self.port_override = port_override if port_override is not None else 0
9523        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9524        '''
9525         ID of the secret store containing credentials for this resource, if any.
9526        '''
9527        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9528        '''
9529         Tags is a map of key, value pairs.
9530        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9547    def to_dict(self):
9548        return {
9549            'bind_interface': self.bind_interface,
9550            'egress_filter': self.egress_filter,
9551            'healthy': self.healthy,
9552            'hostname': self.hostname,
9553            'id': self.id,
9554            'name': self.name,
9555            'password': self.password,
9556            'port': self.port,
9557            'port_override': self.port_override,
9558            'secret_store_id': self.secret_store_id,
9559            'tags': self.tags,
9560        }
@classmethod
def from_dict(cls, d)
9562    @classmethod
9563    def from_dict(cls, d):
9564        return cls(
9565            bind_interface=d.get('bind_interface'),
9566            egress_filter=d.get('egress_filter'),
9567            healthy=d.get('healthy'),
9568            hostname=d.get('hostname'),
9569            id=d.get('id'),
9570            name=d.get('name'),
9571            password=d.get('password'),
9572            port=d.get('port'),
9573            port_override=d.get('port_override'),
9574            secret_store_id=d.get('secret_store_id'),
9575            tags=d.get('tags'),
9576        )
class Redshift:
9579class Redshift:
9580    __slots__ = [
9581        'bind_interface',
9582        'database',
9583        'egress_filter',
9584        'healthy',
9585        'hostname',
9586        'id',
9587        'name',
9588        'override_database',
9589        'password',
9590        'port',
9591        'port_override',
9592        'secret_store_id',
9593        'tags',
9594        'username',
9595    ]
9596
9597    def __init__(
9598        self,
9599        bind_interface=None,
9600        database=None,
9601        egress_filter=None,
9602        healthy=None,
9603        hostname=None,
9604        id=None,
9605        name=None,
9606        override_database=None,
9607        password=None,
9608        port=None,
9609        port_override=None,
9610        secret_store_id=None,
9611        tags=None,
9612        username=None,
9613    ):
9614        self.bind_interface = bind_interface if bind_interface is not None else ''
9615        '''
9616         Bind interface
9617        '''
9618        self.database = database if database is not None else ''
9619        self.egress_filter = egress_filter if egress_filter is not None else ''
9620        '''
9621         A filter applied to the routing logic to pin datasource to nodes.
9622        '''
9623        self.healthy = healthy if healthy is not None else False
9624        '''
9625         True if the datasource is reachable and the credentials are valid.
9626        '''
9627        self.hostname = hostname if hostname is not None else ''
9628        self.id = id if id is not None else ''
9629        '''
9630         Unique identifier of the Resource.
9631        '''
9632        self.name = name if name is not None else ''
9633        '''
9634         Unique human-readable name of the Resource.
9635        '''
9636        self.override_database = override_database if override_database is not None else False
9637        self.password = password if password is not None else ''
9638        self.port = port if port is not None else 0
9639        self.port_override = port_override if port_override is not None else 0
9640        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9641        '''
9642         ID of the secret store containing credentials for this resource, if any.
9643        '''
9644        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9645        '''
9646         Tags is a map of key, value pairs.
9647        '''
9648        self.username = username if username is not None else ''
9649
9650    def __repr__(self):
9651        return '<sdm.Redshift ' + \
9652            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9653            'database: ' + repr(self.database) + ' ' +\
9654            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9655            'healthy: ' + repr(self.healthy) + ' ' +\
9656            'hostname: ' + repr(self.hostname) + ' ' +\
9657            'id: ' + repr(self.id) + ' ' +\
9658            'name: ' + repr(self.name) + ' ' +\
9659            'override_database: ' + repr(self.override_database) + ' ' +\
9660            'password: ' + repr(self.password) + ' ' +\
9661            'port: ' + repr(self.port) + ' ' +\
9662            'port_override: ' + repr(self.port_override) + ' ' +\
9663            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9664            'tags: ' + repr(self.tags) + ' ' +\
9665            'username: ' + repr(self.username) + ' ' +\
9666            '>'
9667
9668    def to_dict(self):
9669        return {
9670            'bind_interface': self.bind_interface,
9671            'database': self.database,
9672            'egress_filter': self.egress_filter,
9673            'healthy': self.healthy,
9674            'hostname': self.hostname,
9675            'id': self.id,
9676            'name': self.name,
9677            'override_database': self.override_database,
9678            'password': self.password,
9679            'port': self.port,
9680            'port_override': self.port_override,
9681            'secret_store_id': self.secret_store_id,
9682            'tags': self.tags,
9683            'username': self.username,
9684        }
9685
9686    @classmethod
9687    def from_dict(cls, d):
9688        return cls(
9689            bind_interface=d.get('bind_interface'),
9690            database=d.get('database'),
9691            egress_filter=d.get('egress_filter'),
9692            healthy=d.get('healthy'),
9693            hostname=d.get('hostname'),
9694            id=d.get('id'),
9695            name=d.get('name'),
9696            override_database=d.get('override_database'),
9697            password=d.get('password'),
9698            port=d.get('port'),
9699            port_override=d.get('port_override'),
9700            secret_store_id=d.get('secret_store_id'),
9701            tags=d.get('tags'),
9702            username=d.get('username'),
9703        )
Redshift( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9597    def __init__(
9598        self,
9599        bind_interface=None,
9600        database=None,
9601        egress_filter=None,
9602        healthy=None,
9603        hostname=None,
9604        id=None,
9605        name=None,
9606        override_database=None,
9607        password=None,
9608        port=None,
9609        port_override=None,
9610        secret_store_id=None,
9611        tags=None,
9612        username=None,
9613    ):
9614        self.bind_interface = bind_interface if bind_interface is not None else ''
9615        '''
9616         Bind interface
9617        '''
9618        self.database = database if database is not None else ''
9619        self.egress_filter = egress_filter if egress_filter is not None else ''
9620        '''
9621         A filter applied to the routing logic to pin datasource to nodes.
9622        '''
9623        self.healthy = healthy if healthy is not None else False
9624        '''
9625         True if the datasource is reachable and the credentials are valid.
9626        '''
9627        self.hostname = hostname if hostname is not None else ''
9628        self.id = id if id is not None else ''
9629        '''
9630         Unique identifier of the Resource.
9631        '''
9632        self.name = name if name is not None else ''
9633        '''
9634         Unique human-readable name of the Resource.
9635        '''
9636        self.override_database = override_database if override_database is not None else False
9637        self.password = password if password is not None else ''
9638        self.port = port if port is not None else 0
9639        self.port_override = port_override if port_override is not None else 0
9640        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9641        '''
9642         ID of the secret store containing credentials for this resource, if any.
9643        '''
9644        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9645        '''
9646         Tags is a map of key, value pairs.
9647        '''
9648        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9668    def to_dict(self):
9669        return {
9670            'bind_interface': self.bind_interface,
9671            'database': self.database,
9672            'egress_filter': self.egress_filter,
9673            'healthy': self.healthy,
9674            'hostname': self.hostname,
9675            'id': self.id,
9676            'name': self.name,
9677            'override_database': self.override_database,
9678            'password': self.password,
9679            'port': self.port,
9680            'port_override': self.port_override,
9681            'secret_store_id': self.secret_store_id,
9682            'tags': self.tags,
9683            'username': self.username,
9684        }
@classmethod
def from_dict(cls, d)
9686    @classmethod
9687    def from_dict(cls, d):
9688        return cls(
9689            bind_interface=d.get('bind_interface'),
9690            database=d.get('database'),
9691            egress_filter=d.get('egress_filter'),
9692            healthy=d.get('healthy'),
9693            hostname=d.get('hostname'),
9694            id=d.get('id'),
9695            name=d.get('name'),
9696            override_database=d.get('override_database'),
9697            password=d.get('password'),
9698            port=d.get('port'),
9699            port_override=d.get('port_override'),
9700            secret_store_id=d.get('secret_store_id'),
9701            tags=d.get('tags'),
9702            username=d.get('username'),
9703        )
class Relay:
9706class Relay:
9707    '''
9708         Relay represents a StrongDM CLI installation running in relay mode.
9709    '''
9710    __slots__ = [
9711        'device',
9712        'gateway_filter',
9713        'id',
9714        'location',
9715        'name',
9716        'state',
9717        'tags',
9718        'version',
9719    ]
9720
9721    def __init__(
9722        self,
9723        device=None,
9724        gateway_filter=None,
9725        id=None,
9726        location=None,
9727        name=None,
9728        state=None,
9729        tags=None,
9730        version=None,
9731    ):
9732        self.device = device if device is not None else ''
9733        '''
9734         Device is a read only device name uploaded by the gateway process when 
9735         it comes online.
9736        '''
9737        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9738        '''
9739         GatewayFilter can be used to restrict the peering between relays and
9740         gateways.
9741        '''
9742        self.id = id if id is not None else ''
9743        '''
9744         Unique identifier of the Relay.
9745        '''
9746        self.location = location if location is not None else ''
9747        '''
9748         Location is a read only network location uploaded by the gateway process
9749         when it comes online.
9750        '''
9751        self.name = name if name is not None else ''
9752        '''
9753         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9754        '''
9755        self.state = state if state is not None else ''
9756        '''
9757         The current state of the relay. One of: "new", "verifying_restart",
9758         "awaiting_restart", "restarting", "started", "stopped", "dead",
9759         "unknown".
9760        '''
9761        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9762        '''
9763         Tags is a map of key, value pairs.
9764        '''
9765        self.version = version if version is not None else ''
9766        '''
9767         Version is a read only sdm binary version uploaded by the gateway process
9768         when it comes online.
9769        '''
9770
9771    def __repr__(self):
9772        return '<sdm.Relay ' + \
9773            'device: ' + repr(self.device) + ' ' +\
9774            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
9775            'id: ' + repr(self.id) + ' ' +\
9776            'location: ' + repr(self.location) + ' ' +\
9777            'name: ' + repr(self.name) + ' ' +\
9778            'state: ' + repr(self.state) + ' ' +\
9779            'tags: ' + repr(self.tags) + ' ' +\
9780            'version: ' + repr(self.version) + ' ' +\
9781            '>'
9782
9783    def to_dict(self):
9784        return {
9785            'device': self.device,
9786            'gateway_filter': self.gateway_filter,
9787            'id': self.id,
9788            'location': self.location,
9789            'name': self.name,
9790            'state': self.state,
9791            'tags': self.tags,
9792            'version': self.version,
9793        }
9794
9795    @classmethod
9796    def from_dict(cls, d):
9797        return cls(
9798            device=d.get('device'),
9799            gateway_filter=d.get('gateway_filter'),
9800            id=d.get('id'),
9801            location=d.get('location'),
9802            name=d.get('name'),
9803            state=d.get('state'),
9804            tags=d.get('tags'),
9805            version=d.get('version'),
9806        )

Relay represents a StrongDM CLI installation running in relay mode.

Relay( device=None, gateway_filter=None, id=None, location=None, name=None, state=None, tags=None, version=None)
9721    def __init__(
9722        self,
9723        device=None,
9724        gateway_filter=None,
9725        id=None,
9726        location=None,
9727        name=None,
9728        state=None,
9729        tags=None,
9730        version=None,
9731    ):
9732        self.device = device if device is not None else ''
9733        '''
9734         Device is a read only device name uploaded by the gateway process when 
9735         it comes online.
9736        '''
9737        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
9738        '''
9739         GatewayFilter can be used to restrict the peering between relays and
9740         gateways.
9741        '''
9742        self.id = id if id is not None else ''
9743        '''
9744         Unique identifier of the Relay.
9745        '''
9746        self.location = location if location is not None else ''
9747        '''
9748         Location is a read only network location uploaded by the gateway process
9749         when it comes online.
9750        '''
9751        self.name = name if name is not None else ''
9752        '''
9753         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
9754        '''
9755        self.state = state if state is not None else ''
9756        '''
9757         The current state of the relay. One of: "new", "verifying_restart",
9758         "awaiting_restart", "restarting", "started", "stopped", "dead",
9759         "unknown".
9760        '''
9761        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9762        '''
9763         Tags is a map of key, value pairs.
9764        '''
9765        self.version = version if version is not None else ''
9766        '''
9767         Version is a read only sdm binary version uploaded by the gateway process
9768         when it comes online.
9769        '''
device

Device is a read only device name uploaded by the gateway process when it comes online.

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Relay.

location

Location is a read only network location uploaded by the gateway process when it comes online.

name

Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".

tags

Tags is a map of key, value pairs.

version

Version is a read only sdm binary version uploaded by the gateway process when it comes online.

def to_dict(self)
9783    def to_dict(self):
9784        return {
9785            'device': self.device,
9786            'gateway_filter': self.gateway_filter,
9787            'id': self.id,
9788            'location': self.location,
9789            'name': self.name,
9790            'state': self.state,
9791            'tags': self.tags,
9792            'version': self.version,
9793        }
@classmethod
def from_dict(cls, d)
9795    @classmethod
9796    def from_dict(cls, d):
9797        return cls(
9798            device=d.get('device'),
9799            gateway_filter=d.get('gateway_filter'),
9800            id=d.get('id'),
9801            location=d.get('location'),
9802            name=d.get('name'),
9803            state=d.get('state'),
9804            tags=d.get('tags'),
9805            version=d.get('version'),
9806        )
class RemoteIdentity:
9809class RemoteIdentity:
9810    '''
9811         RemoteIdentities define the username to be used for a specific account
9812     when connecting to a remote resource using that group.
9813    '''
9814    __slots__ = [
9815        'account_id',
9816        'id',
9817        'remote_identity_group_id',
9818        'username',
9819    ]
9820
9821    def __init__(
9822        self,
9823        account_id=None,
9824        id=None,
9825        remote_identity_group_id=None,
9826        username=None,
9827    ):
9828        self.account_id = account_id if account_id is not None else ''
9829        '''
9830         The account for this remote identity.
9831        '''
9832        self.id = id if id is not None else ''
9833        '''
9834         Unique identifier of the RemoteIdentity.
9835        '''
9836        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9837        '''
9838         The remote identity group.
9839        '''
9840        self.username = username if username is not None else ''
9841        '''
9842         The username to be used as the remote identity for this account.
9843        '''
9844
9845    def __repr__(self):
9846        return '<sdm.RemoteIdentity ' + \
9847            'account_id: ' + repr(self.account_id) + ' ' +\
9848            'id: ' + repr(self.id) + ' ' +\
9849            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
9850            'username: ' + repr(self.username) + ' ' +\
9851            '>'
9852
9853    def to_dict(self):
9854        return {
9855            'account_id': self.account_id,
9856            'id': self.id,
9857            'remote_identity_group_id': self.remote_identity_group_id,
9858            'username': self.username,
9859        }
9860
9861    @classmethod
9862    def from_dict(cls, d):
9863        return cls(
9864            account_id=d.get('account_id'),
9865            id=d.get('id'),
9866            remote_identity_group_id=d.get('remote_identity_group_id'),
9867            username=d.get('username'),
9868        )

RemoteIdentities define the username to be used for a specific account when connecting to a remote resource using that group.

RemoteIdentity( account_id=None, id=None, remote_identity_group_id=None, username=None)
9821    def __init__(
9822        self,
9823        account_id=None,
9824        id=None,
9825        remote_identity_group_id=None,
9826        username=None,
9827    ):
9828        self.account_id = account_id if account_id is not None else ''
9829        '''
9830         The account for this remote identity.
9831        '''
9832        self.id = id if id is not None else ''
9833        '''
9834         Unique identifier of the RemoteIdentity.
9835        '''
9836        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
9837        '''
9838         The remote identity group.
9839        '''
9840        self.username = username if username is not None else ''
9841        '''
9842         The username to be used as the remote identity for this account.
9843        '''
account_id

The account for this remote identity.

id

Unique identifier of the RemoteIdentity.

remote_identity_group_id

The remote identity group.

username

The username to be used as the remote identity for this account.

def to_dict(self)
9853    def to_dict(self):
9854        return {
9855            'account_id': self.account_id,
9856            'id': self.id,
9857            'remote_identity_group_id': self.remote_identity_group_id,
9858            'username': self.username,
9859        }
@classmethod
def from_dict(cls, d)
9861    @classmethod
9862    def from_dict(cls, d):
9863        return cls(
9864            account_id=d.get('account_id'),
9865            id=d.get('id'),
9866            remote_identity_group_id=d.get('remote_identity_group_id'),
9867            username=d.get('username'),
9868        )
class RemoteIdentityCreateResponse:
9871class RemoteIdentityCreateResponse:
9872    '''
9873         RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
9874    '''
9875    __slots__ = [
9876        'meta',
9877        'rate_limit',
9878        'remote_identity',
9879    ]
9880
9881    def __init__(
9882        self,
9883        meta=None,
9884        rate_limit=None,
9885        remote_identity=None,
9886    ):
9887        self.meta = meta if meta is not None else None
9888        '''
9889         Reserved for future use.
9890        '''
9891        self.rate_limit = rate_limit if rate_limit is not None else None
9892        '''
9893         Rate limit information.
9894        '''
9895        self.remote_identity = remote_identity if remote_identity is not None else None
9896        '''
9897         The created RemoteIdentity.
9898        '''
9899
9900    def __repr__(self):
9901        return '<sdm.RemoteIdentityCreateResponse ' + \
9902            'meta: ' + repr(self.meta) + ' ' +\
9903            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9904            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
9905            '>'
9906
9907    def to_dict(self):
9908        return {
9909            'meta': self.meta,
9910            'rate_limit': self.rate_limit,
9911            'remote_identity': self.remote_identity,
9912        }
9913
9914    @classmethod
9915    def from_dict(cls, d):
9916        return cls(
9917            meta=d.get('meta'),
9918            rate_limit=d.get('rate_limit'),
9919            remote_identity=d.get('remote_identity'),
9920        )

RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.

RemoteIdentityCreateResponse(meta=None, rate_limit=None, remote_identity=None)
9881    def __init__(
9882        self,
9883        meta=None,
9884        rate_limit=None,
9885        remote_identity=None,
9886    ):
9887        self.meta = meta if meta is not None else None
9888        '''
9889         Reserved for future use.
9890        '''
9891        self.rate_limit = rate_limit if rate_limit is not None else None
9892        '''
9893         Rate limit information.
9894        '''
9895        self.remote_identity = remote_identity if remote_identity is not None else None
9896        '''
9897         The created RemoteIdentity.
9898        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The created RemoteIdentity.

def to_dict(self)
9907    def to_dict(self):
9908        return {
9909            'meta': self.meta,
9910            'rate_limit': self.rate_limit,
9911            'remote_identity': self.remote_identity,
9912        }
@classmethod
def from_dict(cls, d)
9914    @classmethod
9915    def from_dict(cls, d):
9916        return cls(
9917            meta=d.get('meta'),
9918            rate_limit=d.get('rate_limit'),
9919            remote_identity=d.get('remote_identity'),
9920        )
class RemoteIdentityDeleteResponse:
9923class RemoteIdentityDeleteResponse:
9924    '''
9925         RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
9926    '''
9927    __slots__ = [
9928        'meta',
9929        'rate_limit',
9930    ]
9931
9932    def __init__(
9933        self,
9934        meta=None,
9935        rate_limit=None,
9936    ):
9937        self.meta = meta if meta is not None else None
9938        '''
9939         Reserved for future use.
9940        '''
9941        self.rate_limit = rate_limit if rate_limit is not None else None
9942        '''
9943         Rate limit information.
9944        '''
9945
9946    def __repr__(self):
9947        return '<sdm.RemoteIdentityDeleteResponse ' + \
9948            'meta: ' + repr(self.meta) + ' ' +\
9949            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9950            '>'
9951
9952    def to_dict(self):
9953        return {
9954            'meta': self.meta,
9955            'rate_limit': self.rate_limit,
9956        }
9957
9958    @classmethod
9959    def from_dict(cls, d):
9960        return cls(
9961            meta=d.get('meta'),
9962            rate_limit=d.get('rate_limit'),
9963        )

RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.

RemoteIdentityDeleteResponse(meta=None, rate_limit=None)
9932    def __init__(
9933        self,
9934        meta=None,
9935        rate_limit=None,
9936    ):
9937        self.meta = meta if meta is not None else None
9938        '''
9939         Reserved for future use.
9940        '''
9941        self.rate_limit = rate_limit if rate_limit is not None else None
9942        '''
9943         Rate limit information.
9944        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
9952    def to_dict(self):
9953        return {
9954            'meta': self.meta,
9955            'rate_limit': self.rate_limit,
9956        }
@classmethod
def from_dict(cls, d)
9958    @classmethod
9959    def from_dict(cls, d):
9960        return cls(
9961            meta=d.get('meta'),
9962            rate_limit=d.get('rate_limit'),
9963        )
class RemoteIdentityGetResponse:
 9966class RemoteIdentityGetResponse:
 9967    '''
 9968         RemoteIdentityGetResponse returns a requested RemoteIdentity.
 9969    '''
 9970    __slots__ = [
 9971        'meta',
 9972        'rate_limit',
 9973        'remote_identity',
 9974    ]
 9975
 9976    def __init__(
 9977        self,
 9978        meta=None,
 9979        rate_limit=None,
 9980        remote_identity=None,
 9981    ):
 9982        self.meta = meta if meta is not None else None
 9983        '''
 9984         Reserved for future use.
 9985        '''
 9986        self.rate_limit = rate_limit if rate_limit is not None else None
 9987        '''
 9988         Rate limit information.
 9989        '''
 9990        self.remote_identity = remote_identity if remote_identity is not None else None
 9991        '''
 9992         The requested RemoteIdentity.
 9993        '''
 9994
 9995    def __repr__(self):
 9996        return '<sdm.RemoteIdentityGetResponse ' + \
 9997            'meta: ' + repr(self.meta) + ' ' +\
 9998            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9999            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10000            '>'
10001
10002    def to_dict(self):
10003        return {
10004            'meta': self.meta,
10005            'rate_limit': self.rate_limit,
10006            'remote_identity': self.remote_identity,
10007        }
10008
10009    @classmethod
10010    def from_dict(cls, d):
10011        return cls(
10012            meta=d.get('meta'),
10013            rate_limit=d.get('rate_limit'),
10014            remote_identity=d.get('remote_identity'),
10015        )

RemoteIdentityGetResponse returns a requested RemoteIdentity.

RemoteIdentityGetResponse(meta=None, rate_limit=None, remote_identity=None)
9976    def __init__(
9977        self,
9978        meta=None,
9979        rate_limit=None,
9980        remote_identity=None,
9981    ):
9982        self.meta = meta if meta is not None else None
9983        '''
9984         Reserved for future use.
9985        '''
9986        self.rate_limit = rate_limit if rate_limit is not None else None
9987        '''
9988         Rate limit information.
9989        '''
9990        self.remote_identity = remote_identity if remote_identity is not None else None
9991        '''
9992         The requested RemoteIdentity.
9993        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The requested RemoteIdentity.

def to_dict(self)
10002    def to_dict(self):
10003        return {
10004            'meta': self.meta,
10005            'rate_limit': self.rate_limit,
10006            'remote_identity': self.remote_identity,
10007        }
@classmethod
def from_dict(cls, d)
10009    @classmethod
10010    def from_dict(cls, d):
10011        return cls(
10012            meta=d.get('meta'),
10013            rate_limit=d.get('rate_limit'),
10014            remote_identity=d.get('remote_identity'),
10015        )
class RemoteIdentityGroup:
10018class RemoteIdentityGroup:
10019    '''
10020         A RemoteIdentityGroup defines a group of remote identities.
10021    '''
10022    __slots__ = [
10023        'id',
10024        'name',
10025    ]
10026
10027    def __init__(
10028        self,
10029        id=None,
10030        name=None,
10031    ):
10032        self.id = id if id is not None else ''
10033        '''
10034         Unique identifier of the RemoteIdentityGroup.
10035        '''
10036        self.name = name if name is not None else ''
10037        '''
10038         Unique human-readable name of the RemoteIdentityGroup.
10039        '''
10040
10041    def __repr__(self):
10042        return '<sdm.RemoteIdentityGroup ' + \
10043            'id: ' + repr(self.id) + ' ' +\
10044            'name: ' + repr(self.name) + ' ' +\
10045            '>'
10046
10047    def to_dict(self):
10048        return {
10049            'id': self.id,
10050            'name': self.name,
10051        }
10052
10053    @classmethod
10054    def from_dict(cls, d):
10055        return cls(
10056            id=d.get('id'),
10057            name=d.get('name'),
10058        )

A RemoteIdentityGroup defines a group of remote identities.

RemoteIdentityGroup(id=None, name=None)
10027    def __init__(
10028        self,
10029        id=None,
10030        name=None,
10031    ):
10032        self.id = id if id is not None else ''
10033        '''
10034         Unique identifier of the RemoteIdentityGroup.
10035        '''
10036        self.name = name if name is not None else ''
10037        '''
10038         Unique human-readable name of the RemoteIdentityGroup.
10039        '''
id

Unique identifier of the RemoteIdentityGroup.

name

Unique human-readable name of the RemoteIdentityGroup.

def to_dict(self)
10047    def to_dict(self):
10048        return {
10049            'id': self.id,
10050            'name': self.name,
10051        }
@classmethod
def from_dict(cls, d)
10053    @classmethod
10054    def from_dict(cls, d):
10055        return cls(
10056            id=d.get('id'),
10057            name=d.get('name'),
10058        )
class RemoteIdentityGroupGetResponse:
10061class RemoteIdentityGroupGetResponse:
10062    '''
10063         RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10064    '''
10065    __slots__ = [
10066        'meta',
10067        'rate_limit',
10068        'remote_identity_group',
10069    ]
10070
10071    def __init__(
10072        self,
10073        meta=None,
10074        rate_limit=None,
10075        remote_identity_group=None,
10076    ):
10077        self.meta = meta if meta is not None else None
10078        '''
10079         Reserved for future use.
10080        '''
10081        self.rate_limit = rate_limit if rate_limit is not None else None
10082        '''
10083         Rate limit information.
10084        '''
10085        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10086        '''
10087         The requested RemoteIdentityGroup.
10088        '''
10089
10090    def __repr__(self):
10091        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10092            'meta: ' + repr(self.meta) + ' ' +\
10093            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10094            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10095            '>'
10096
10097    def to_dict(self):
10098        return {
10099            'meta': self.meta,
10100            'rate_limit': self.rate_limit,
10101            'remote_identity_group': self.remote_identity_group,
10102        }
10103
10104    @classmethod
10105    def from_dict(cls, d):
10106        return cls(
10107            meta=d.get('meta'),
10108            rate_limit=d.get('rate_limit'),
10109            remote_identity_group=d.get('remote_identity_group'),
10110        )

RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.

RemoteIdentityGroupGetResponse(meta=None, rate_limit=None, remote_identity_group=None)
10071    def __init__(
10072        self,
10073        meta=None,
10074        rate_limit=None,
10075        remote_identity_group=None,
10076    ):
10077        self.meta = meta if meta is not None else None
10078        '''
10079         Reserved for future use.
10080        '''
10081        self.rate_limit = rate_limit if rate_limit is not None else None
10082        '''
10083         Rate limit information.
10084        '''
10085        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10086        '''
10087         The requested RemoteIdentityGroup.
10088        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity_group

The requested RemoteIdentityGroup.

def to_dict(self)
10097    def to_dict(self):
10098        return {
10099            'meta': self.meta,
10100            'rate_limit': self.rate_limit,
10101            'remote_identity_group': self.remote_identity_group,
10102        }
@classmethod
def from_dict(cls, d)
10104    @classmethod
10105    def from_dict(cls, d):
10106        return cls(
10107            meta=d.get('meta'),
10108            rate_limit=d.get('rate_limit'),
10109            remote_identity_group=d.get('remote_identity_group'),
10110        )
class RemoteIdentityUpdateResponse:
10113class RemoteIdentityUpdateResponse:
10114    '''
10115         RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10116     a RemoteIdentityUpdateRequest.
10117    '''
10118    __slots__ = [
10119        'meta',
10120        'rate_limit',
10121        'remote_identity',
10122    ]
10123
10124    def __init__(
10125        self,
10126        meta=None,
10127        rate_limit=None,
10128        remote_identity=None,
10129    ):
10130        self.meta = meta if meta is not None else None
10131        '''
10132         Reserved for future use.
10133        '''
10134        self.rate_limit = rate_limit if rate_limit is not None else None
10135        '''
10136         Rate limit information.
10137        '''
10138        self.remote_identity = remote_identity if remote_identity is not None else None
10139        '''
10140         The updated RemoteIdentity.
10141        '''
10142
10143    def __repr__(self):
10144        return '<sdm.RemoteIdentityUpdateResponse ' + \
10145            'meta: ' + repr(self.meta) + ' ' +\
10146            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10147            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10148            '>'
10149
10150    def to_dict(self):
10151        return {
10152            'meta': self.meta,
10153            'rate_limit': self.rate_limit,
10154            'remote_identity': self.remote_identity,
10155        }
10156
10157    @classmethod
10158    def from_dict(cls, d):
10159        return cls(
10160            meta=d.get('meta'),
10161            rate_limit=d.get('rate_limit'),
10162            remote_identity=d.get('remote_identity'),
10163        )

RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by a RemoteIdentityUpdateRequest.

RemoteIdentityUpdateResponse(meta=None, rate_limit=None, remote_identity=None)
10124    def __init__(
10125        self,
10126        meta=None,
10127        rate_limit=None,
10128        remote_identity=None,
10129    ):
10130        self.meta = meta if meta is not None else None
10131        '''
10132         Reserved for future use.
10133        '''
10134        self.rate_limit = rate_limit if rate_limit is not None else None
10135        '''
10136         Rate limit information.
10137        '''
10138        self.remote_identity = remote_identity if remote_identity is not None else None
10139        '''
10140         The updated RemoteIdentity.
10141        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The updated RemoteIdentity.

def to_dict(self)
10150    def to_dict(self):
10151        return {
10152            'meta': self.meta,
10153            'rate_limit': self.rate_limit,
10154            'remote_identity': self.remote_identity,
10155        }
@classmethod
def from_dict(cls, d)
10157    @classmethod
10158    def from_dict(cls, d):
10159        return cls(
10160            meta=d.get('meta'),
10161            rate_limit=d.get('rate_limit'),
10162            remote_identity=d.get('remote_identity'),
10163        )
class ResourceCreateResponse:
10166class ResourceCreateResponse:
10167    '''
10168         ResourceCreateResponse reports how the Resources were created in the system.
10169    '''
10170    __slots__ = [
10171        'meta',
10172        'rate_limit',
10173        'resource',
10174    ]
10175
10176    def __init__(
10177        self,
10178        meta=None,
10179        rate_limit=None,
10180        resource=None,
10181    ):
10182        self.meta = meta if meta is not None else None
10183        '''
10184         Reserved for future use.
10185        '''
10186        self.rate_limit = rate_limit if rate_limit is not None else None
10187        '''
10188         Rate limit information.
10189        '''
10190        self.resource = resource if resource is not None else None
10191        '''
10192         The created Resource.
10193        '''
10194
10195    def __repr__(self):
10196        return '<sdm.ResourceCreateResponse ' + \
10197            'meta: ' + repr(self.meta) + ' ' +\
10198            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10199            'resource: ' + repr(self.resource) + ' ' +\
10200            '>'
10201
10202    def to_dict(self):
10203        return {
10204            'meta': self.meta,
10205            'rate_limit': self.rate_limit,
10206            'resource': self.resource,
10207        }
10208
10209    @classmethod
10210    def from_dict(cls, d):
10211        return cls(
10212            meta=d.get('meta'),
10213            rate_limit=d.get('rate_limit'),
10214            resource=d.get('resource'),
10215        )

ResourceCreateResponse reports how the Resources were created in the system.

ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
10176    def __init__(
10177        self,
10178        meta=None,
10179        rate_limit=None,
10180        resource=None,
10181    ):
10182        self.meta = meta if meta is not None else None
10183        '''
10184         Reserved for future use.
10185        '''
10186        self.rate_limit = rate_limit if rate_limit is not None else None
10187        '''
10188         Rate limit information.
10189        '''
10190        self.resource = resource if resource is not None else None
10191        '''
10192         The created Resource.
10193        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The created Resource.

def to_dict(self)
10202    def to_dict(self):
10203        return {
10204            'meta': self.meta,
10205            'rate_limit': self.rate_limit,
10206            'resource': self.resource,
10207        }
@classmethod
def from_dict(cls, d)
10209    @classmethod
10210    def from_dict(cls, d):
10211        return cls(
10212            meta=d.get('meta'),
10213            rate_limit=d.get('rate_limit'),
10214            resource=d.get('resource'),
10215        )
class ResourceDeleteResponse:
10218class ResourceDeleteResponse:
10219    '''
10220         ResourceDeleteResponse returns information about a Resource that was deleted.
10221    '''
10222    __slots__ = [
10223        'meta',
10224        'rate_limit',
10225    ]
10226
10227    def __init__(
10228        self,
10229        meta=None,
10230        rate_limit=None,
10231    ):
10232        self.meta = meta if meta is not None else None
10233        '''
10234         Reserved for future use.
10235        '''
10236        self.rate_limit = rate_limit if rate_limit is not None else None
10237        '''
10238         Rate limit information.
10239        '''
10240
10241    def __repr__(self):
10242        return '<sdm.ResourceDeleteResponse ' + \
10243            'meta: ' + repr(self.meta) + ' ' +\
10244            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10245            '>'
10246
10247    def to_dict(self):
10248        return {
10249            'meta': self.meta,
10250            'rate_limit': self.rate_limit,
10251        }
10252
10253    @classmethod
10254    def from_dict(cls, d):
10255        return cls(
10256            meta=d.get('meta'),
10257            rate_limit=d.get('rate_limit'),
10258        )

ResourceDeleteResponse returns information about a Resource that was deleted.

ResourceDeleteResponse(meta=None, rate_limit=None)
10227    def __init__(
10228        self,
10229        meta=None,
10230        rate_limit=None,
10231    ):
10232        self.meta = meta if meta is not None else None
10233        '''
10234         Reserved for future use.
10235        '''
10236        self.rate_limit = rate_limit if rate_limit is not None else None
10237        '''
10238         Rate limit information.
10239        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10247    def to_dict(self):
10248        return {
10249            'meta': self.meta,
10250            'rate_limit': self.rate_limit,
10251        }
@classmethod
def from_dict(cls, d)
10253    @classmethod
10254    def from_dict(cls, d):
10255        return cls(
10256            meta=d.get('meta'),
10257            rate_limit=d.get('rate_limit'),
10258        )
class ResourceGetResponse:
10261class ResourceGetResponse:
10262    '''
10263         ResourceGetResponse returns a requested Resource.
10264    '''
10265    __slots__ = [
10266        'meta',
10267        'rate_limit',
10268        'resource',
10269    ]
10270
10271    def __init__(
10272        self,
10273        meta=None,
10274        rate_limit=None,
10275        resource=None,
10276    ):
10277        self.meta = meta if meta is not None else None
10278        '''
10279         Reserved for future use.
10280        '''
10281        self.rate_limit = rate_limit if rate_limit is not None else None
10282        '''
10283         Rate limit information.
10284        '''
10285        self.resource = resource if resource is not None else None
10286        '''
10287         The requested Resource.
10288        '''
10289
10290    def __repr__(self):
10291        return '<sdm.ResourceGetResponse ' + \
10292            'meta: ' + repr(self.meta) + ' ' +\
10293            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10294            'resource: ' + repr(self.resource) + ' ' +\
10295            '>'
10296
10297    def to_dict(self):
10298        return {
10299            'meta': self.meta,
10300            'rate_limit': self.rate_limit,
10301            'resource': self.resource,
10302        }
10303
10304    @classmethod
10305    def from_dict(cls, d):
10306        return cls(
10307            meta=d.get('meta'),
10308            rate_limit=d.get('rate_limit'),
10309            resource=d.get('resource'),
10310        )

ResourceGetResponse returns a requested Resource.

ResourceGetResponse(meta=None, rate_limit=None, resource=None)
10271    def __init__(
10272        self,
10273        meta=None,
10274        rate_limit=None,
10275        resource=None,
10276    ):
10277        self.meta = meta if meta is not None else None
10278        '''
10279         Reserved for future use.
10280        '''
10281        self.rate_limit = rate_limit if rate_limit is not None else None
10282        '''
10283         Rate limit information.
10284        '''
10285        self.resource = resource if resource is not None else None
10286        '''
10287         The requested Resource.
10288        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The requested Resource.

def to_dict(self)
10297    def to_dict(self):
10298        return {
10299            'meta': self.meta,
10300            'rate_limit': self.rate_limit,
10301            'resource': self.resource,
10302        }
@classmethod
def from_dict(cls, d)
10304    @classmethod
10305    def from_dict(cls, d):
10306        return cls(
10307            meta=d.get('meta'),
10308            rate_limit=d.get('rate_limit'),
10309            resource=d.get('resource'),
10310        )
class ResourceUpdateResponse:
10313class ResourceUpdateResponse:
10314    '''
10315         ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10316     a ResourceUpdateRequest.
10317    '''
10318    __slots__ = [
10319        'meta',
10320        'rate_limit',
10321        'resource',
10322    ]
10323
10324    def __init__(
10325        self,
10326        meta=None,
10327        rate_limit=None,
10328        resource=None,
10329    ):
10330        self.meta = meta if meta is not None else None
10331        '''
10332         Reserved for future use.
10333        '''
10334        self.rate_limit = rate_limit if rate_limit is not None else None
10335        '''
10336         Rate limit information.
10337        '''
10338        self.resource = resource if resource is not None else None
10339        '''
10340         The updated Resource.
10341        '''
10342
10343    def __repr__(self):
10344        return '<sdm.ResourceUpdateResponse ' + \
10345            'meta: ' + repr(self.meta) + ' ' +\
10346            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10347            'resource: ' + repr(self.resource) + ' ' +\
10348            '>'
10349
10350    def to_dict(self):
10351        return {
10352            'meta': self.meta,
10353            'rate_limit': self.rate_limit,
10354            'resource': self.resource,
10355        }
10356
10357    @classmethod
10358    def from_dict(cls, d):
10359        return cls(
10360            meta=d.get('meta'),
10361            rate_limit=d.get('rate_limit'),
10362            resource=d.get('resource'),
10363        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
10324    def __init__(
10325        self,
10326        meta=None,
10327        rate_limit=None,
10328        resource=None,
10329    ):
10330        self.meta = meta if meta is not None else None
10331        '''
10332         Reserved for future use.
10333        '''
10334        self.rate_limit = rate_limit if rate_limit is not None else None
10335        '''
10336         Rate limit information.
10337        '''
10338        self.resource = resource if resource is not None else None
10339        '''
10340         The updated Resource.
10341        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The updated Resource.

def to_dict(self)
10350    def to_dict(self):
10351        return {
10352            'meta': self.meta,
10353            'rate_limit': self.rate_limit,
10354            'resource': self.resource,
10355        }
@classmethod
def from_dict(cls, d)
10357    @classmethod
10358    def from_dict(cls, d):
10359        return cls(
10360            meta=d.get('meta'),
10361            rate_limit=d.get('rate_limit'),
10362            resource=d.get('resource'),
10363        )
class Role:
10366class Role:
10367    '''
10368         A Role has a list of access rules which determine which Resources the members
10369     of the Role have access to. An Account can be a member of multiple Roles via
10370     AccountAttachments.
10371    '''
10372    __slots__ = [
10373        'access_rules',
10374        'id',
10375        'managed_by',
10376        'name',
10377        'tags',
10378    ]
10379
10380    def __init__(
10381        self,
10382        access_rules=None,
10383        id=None,
10384        managed_by=None,
10385        name=None,
10386        tags=None,
10387    ):
10388        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10389        )
10390        '''
10391         AccessRules is a list of access rules defining the resources this Role has access to.
10392        '''
10393        self.id = id if id is not None else ''
10394        '''
10395         Unique identifier of the Role.
10396        '''
10397        self.managed_by = managed_by if managed_by is not None else ''
10398        '''
10399         Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.
10400        '''
10401        self.name = name if name is not None else ''
10402        '''
10403         Unique human-readable name of the Role.
10404        '''
10405        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10406        '''
10407         Tags is a map of key, value pairs.
10408        '''
10409
10410    def __repr__(self):
10411        return '<sdm.Role ' + \
10412            'access_rules: ' + repr(self.access_rules) + ' ' +\
10413            'id: ' + repr(self.id) + ' ' +\
10414            'managed_by: ' + repr(self.managed_by) + ' ' +\
10415            'name: ' + repr(self.name) + ' ' +\
10416            'tags: ' + repr(self.tags) + ' ' +\
10417            '>'
10418
10419    def to_dict(self):
10420        return {
10421            'access_rules': self.access_rules,
10422            'id': self.id,
10423            'managed_by': self.managed_by,
10424            'name': self.name,
10425            'tags': self.tags,
10426        }
10427
10428    @classmethod
10429    def from_dict(cls, d):
10430        return cls(
10431            access_rules=d.get('access_rules'),
10432            id=d.get('id'),
10433            managed_by=d.get('managed_by'),
10434            name=d.get('name'),
10435            tags=d.get('tags'),
10436        )

A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.

Role(access_rules=None, id=None, managed_by=None, name=None, tags=None)
10380    def __init__(
10381        self,
10382        access_rules=None,
10383        id=None,
10384        managed_by=None,
10385        name=None,
10386        tags=None,
10387    ):
10388        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10389        )
10390        '''
10391         AccessRules is a list of access rules defining the resources this Role has access to.
10392        '''
10393        self.id = id if id is not None else ''
10394        '''
10395         Unique identifier of the Role.
10396        '''
10397        self.managed_by = managed_by if managed_by is not None else ''
10398        '''
10399         Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.
10400        '''
10401        self.name = name if name is not None else ''
10402        '''
10403         Unique human-readable name of the Role.
10404        '''
10405        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10406        '''
10407         Tags is a map of key, value pairs.
10408        '''
access_rules

AccessRules is a list of access rules defining the resources this Role has access to.

id

Unique identifier of the Role.

managed_by

Managed By is a read only field for what service manages this role, e.g. StrongDM, Okta, Azure.

name

Unique human-readable name of the Role.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10419    def to_dict(self):
10420        return {
10421            'access_rules': self.access_rules,
10422            'id': self.id,
10423            'managed_by': self.managed_by,
10424            'name': self.name,
10425            'tags': self.tags,
10426        }
@classmethod
def from_dict(cls, d)
10428    @classmethod
10429    def from_dict(cls, d):
10430        return cls(
10431            access_rules=d.get('access_rules'),
10432            id=d.get('id'),
10433            managed_by=d.get('managed_by'),
10434            name=d.get('name'),
10435            tags=d.get('tags'),
10436        )
class RoleCreateResponse:
10439class RoleCreateResponse:
10440    '''
10441         RoleCreateResponse reports how the Roles were created in the system. It can
10442     communicate partial successes or failures.
10443    '''
10444    __slots__ = [
10445        'meta',
10446        'rate_limit',
10447        'role',
10448    ]
10449
10450    def __init__(
10451        self,
10452        meta=None,
10453        rate_limit=None,
10454        role=None,
10455    ):
10456        self.meta = meta if meta is not None else None
10457        '''
10458         Reserved for future use.
10459        '''
10460        self.rate_limit = rate_limit if rate_limit is not None else None
10461        '''
10462         Rate limit information.
10463        '''
10464        self.role = role if role is not None else None
10465        '''
10466         The created Role.
10467        '''
10468
10469    def __repr__(self):
10470        return '<sdm.RoleCreateResponse ' + \
10471            'meta: ' + repr(self.meta) + ' ' +\
10472            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10473            'role: ' + repr(self.role) + ' ' +\
10474            '>'
10475
10476    def to_dict(self):
10477        return {
10478            'meta': self.meta,
10479            'rate_limit': self.rate_limit,
10480            'role': self.role,
10481        }
10482
10483    @classmethod
10484    def from_dict(cls, d):
10485        return cls(
10486            meta=d.get('meta'),
10487            rate_limit=d.get('rate_limit'),
10488            role=d.get('role'),
10489        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

RoleCreateResponse(meta=None, rate_limit=None, role=None)
10450    def __init__(
10451        self,
10452        meta=None,
10453        rate_limit=None,
10454        role=None,
10455    ):
10456        self.meta = meta if meta is not None else None
10457        '''
10458         Reserved for future use.
10459        '''
10460        self.rate_limit = rate_limit if rate_limit is not None else None
10461        '''
10462         Rate limit information.
10463        '''
10464        self.role = role if role is not None else None
10465        '''
10466         The created Role.
10467        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The created Role.

def to_dict(self)
10476    def to_dict(self):
10477        return {
10478            'meta': self.meta,
10479            'rate_limit': self.rate_limit,
10480            'role': self.role,
10481        }
@classmethod
def from_dict(cls, d)
10483    @classmethod
10484    def from_dict(cls, d):
10485        return cls(
10486            meta=d.get('meta'),
10487            rate_limit=d.get('rate_limit'),
10488            role=d.get('role'),
10489        )
class RoleDeleteResponse:
10492class RoleDeleteResponse:
10493    '''
10494         RoleDeleteResponse returns information about a Role that was deleted.
10495    '''
10496    __slots__ = [
10497        'meta',
10498        'rate_limit',
10499    ]
10500
10501    def __init__(
10502        self,
10503        meta=None,
10504        rate_limit=None,
10505    ):
10506        self.meta = meta if meta is not None else None
10507        '''
10508         Reserved for future use.
10509        '''
10510        self.rate_limit = rate_limit if rate_limit is not None else None
10511        '''
10512         Rate limit information.
10513        '''
10514
10515    def __repr__(self):
10516        return '<sdm.RoleDeleteResponse ' + \
10517            'meta: ' + repr(self.meta) + ' ' +\
10518            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10519            '>'
10520
10521    def to_dict(self):
10522        return {
10523            'meta': self.meta,
10524            'rate_limit': self.rate_limit,
10525        }
10526
10527    @classmethod
10528    def from_dict(cls, d):
10529        return cls(
10530            meta=d.get('meta'),
10531            rate_limit=d.get('rate_limit'),
10532        )

RoleDeleteResponse returns information about a Role that was deleted.

RoleDeleteResponse(meta=None, rate_limit=None)
10501    def __init__(
10502        self,
10503        meta=None,
10504        rate_limit=None,
10505    ):
10506        self.meta = meta if meta is not None else None
10507        '''
10508         Reserved for future use.
10509        '''
10510        self.rate_limit = rate_limit if rate_limit is not None else None
10511        '''
10512         Rate limit information.
10513        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10521    def to_dict(self):
10522        return {
10523            'meta': self.meta,
10524            'rate_limit': self.rate_limit,
10525        }
@classmethod
def from_dict(cls, d)
10527    @classmethod
10528    def from_dict(cls, d):
10529        return cls(
10530            meta=d.get('meta'),
10531            rate_limit=d.get('rate_limit'),
10532        )
class RoleGetResponse:
10535class RoleGetResponse:
10536    '''
10537         RoleGetResponse returns a requested Role.
10538    '''
10539    __slots__ = [
10540        'meta',
10541        'rate_limit',
10542        'role',
10543    ]
10544
10545    def __init__(
10546        self,
10547        meta=None,
10548        rate_limit=None,
10549        role=None,
10550    ):
10551        self.meta = meta if meta is not None else None
10552        '''
10553         Reserved for future use.
10554        '''
10555        self.rate_limit = rate_limit if rate_limit is not None else None
10556        '''
10557         Rate limit information.
10558        '''
10559        self.role = role if role is not None else None
10560        '''
10561         The requested Role.
10562        '''
10563
10564    def __repr__(self):
10565        return '<sdm.RoleGetResponse ' + \
10566            'meta: ' + repr(self.meta) + ' ' +\
10567            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10568            'role: ' + repr(self.role) + ' ' +\
10569            '>'
10570
10571    def to_dict(self):
10572        return {
10573            'meta': self.meta,
10574            'rate_limit': self.rate_limit,
10575            'role': self.role,
10576        }
10577
10578    @classmethod
10579    def from_dict(cls, d):
10580        return cls(
10581            meta=d.get('meta'),
10582            rate_limit=d.get('rate_limit'),
10583            role=d.get('role'),
10584        )

RoleGetResponse returns a requested Role.

RoleGetResponse(meta=None, rate_limit=None, role=None)
10545    def __init__(
10546        self,
10547        meta=None,
10548        rate_limit=None,
10549        role=None,
10550    ):
10551        self.meta = meta if meta is not None else None
10552        '''
10553         Reserved for future use.
10554        '''
10555        self.rate_limit = rate_limit if rate_limit is not None else None
10556        '''
10557         Rate limit information.
10558        '''
10559        self.role = role if role is not None else None
10560        '''
10561         The requested Role.
10562        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The requested Role.

def to_dict(self)
10571    def to_dict(self):
10572        return {
10573            'meta': self.meta,
10574            'rate_limit': self.rate_limit,
10575            'role': self.role,
10576        }
@classmethod
def from_dict(cls, d)
10578    @classmethod
10579    def from_dict(cls, d):
10580        return cls(
10581            meta=d.get('meta'),
10582            rate_limit=d.get('rate_limit'),
10583            role=d.get('role'),
10584        )
class RoleUpdateResponse:
10587class RoleUpdateResponse:
10588    '''
10589         RoleUpdateResponse returns the fields of a Role after it has been updated by
10590     a RoleUpdateRequest.
10591    '''
10592    __slots__ = [
10593        'meta',
10594        'rate_limit',
10595        'role',
10596    ]
10597
10598    def __init__(
10599        self,
10600        meta=None,
10601        rate_limit=None,
10602        role=None,
10603    ):
10604        self.meta = meta if meta is not None else None
10605        '''
10606         Reserved for future use.
10607        '''
10608        self.rate_limit = rate_limit if rate_limit is not None else None
10609        '''
10610         Rate limit information.
10611        '''
10612        self.role = role if role is not None else None
10613        '''
10614         The updated Role.
10615        '''
10616
10617    def __repr__(self):
10618        return '<sdm.RoleUpdateResponse ' + \
10619            'meta: ' + repr(self.meta) + ' ' +\
10620            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10621            'role: ' + repr(self.role) + ' ' +\
10622            '>'
10623
10624    def to_dict(self):
10625        return {
10626            'meta': self.meta,
10627            'rate_limit': self.rate_limit,
10628            'role': self.role,
10629        }
10630
10631    @classmethod
10632    def from_dict(cls, d):
10633        return cls(
10634            meta=d.get('meta'),
10635            rate_limit=d.get('rate_limit'),
10636            role=d.get('role'),
10637        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

RoleUpdateResponse(meta=None, rate_limit=None, role=None)
10598    def __init__(
10599        self,
10600        meta=None,
10601        rate_limit=None,
10602        role=None,
10603    ):
10604        self.meta = meta if meta is not None else None
10605        '''
10606         Reserved for future use.
10607        '''
10608        self.rate_limit = rate_limit if rate_limit is not None else None
10609        '''
10610         Rate limit information.
10611        '''
10612        self.role = role if role is not None else None
10613        '''
10614         The updated Role.
10615        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The updated Role.

def to_dict(self)
10624    def to_dict(self):
10625        return {
10626            'meta': self.meta,
10627            'rate_limit': self.rate_limit,
10628            'role': self.role,
10629        }
@classmethod
def from_dict(cls, d)
10631    @classmethod
10632    def from_dict(cls, d):
10633        return cls(
10634            meta=d.get('meta'),
10635            rate_limit=d.get('rate_limit'),
10636            role=d.get('role'),
10637        )
class SQLServer:
10640class SQLServer:
10641    __slots__ = [
10642        'bind_interface',
10643        'database',
10644        'egress_filter',
10645        'healthy',
10646        'hostname',
10647        'id',
10648        'name',
10649        'override_database',
10650        'password',
10651        'port',
10652        'port_override',
10653        'schema',
10654        'secret_store_id',
10655        'tags',
10656        'username',
10657    ]
10658
10659    def __init__(
10660        self,
10661        bind_interface=None,
10662        database=None,
10663        egress_filter=None,
10664        healthy=None,
10665        hostname=None,
10666        id=None,
10667        name=None,
10668        override_database=None,
10669        password=None,
10670        port=None,
10671        port_override=None,
10672        schema=None,
10673        secret_store_id=None,
10674        tags=None,
10675        username=None,
10676    ):
10677        self.bind_interface = bind_interface if bind_interface is not None else ''
10678        '''
10679         Bind interface
10680        '''
10681        self.database = database if database is not None else ''
10682        self.egress_filter = egress_filter if egress_filter is not None else ''
10683        '''
10684         A filter applied to the routing logic to pin datasource to nodes.
10685        '''
10686        self.healthy = healthy if healthy is not None else False
10687        '''
10688         True if the datasource is reachable and the credentials are valid.
10689        '''
10690        self.hostname = hostname if hostname is not None else ''
10691        self.id = id if id is not None else ''
10692        '''
10693         Unique identifier of the Resource.
10694        '''
10695        self.name = name if name is not None else ''
10696        '''
10697         Unique human-readable name of the Resource.
10698        '''
10699        self.override_database = override_database if override_database is not None else False
10700        self.password = password if password is not None else ''
10701        self.port = port if port is not None else 0
10702        self.port_override = port_override if port_override is not None else 0
10703        self.schema = schema if schema is not None else ''
10704        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10705        '''
10706         ID of the secret store containing credentials for this resource, if any.
10707        '''
10708        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10709        '''
10710         Tags is a map of key, value pairs.
10711        '''
10712        self.username = username if username is not None else ''
10713
10714    def __repr__(self):
10715        return '<sdm.SQLServer ' + \
10716            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10717            'database: ' + repr(self.database) + ' ' +\
10718            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10719            'healthy: ' + repr(self.healthy) + ' ' +\
10720            'hostname: ' + repr(self.hostname) + ' ' +\
10721            'id: ' + repr(self.id) + ' ' +\
10722            'name: ' + repr(self.name) + ' ' +\
10723            'override_database: ' + repr(self.override_database) + ' ' +\
10724            'password: ' + repr(self.password) + ' ' +\
10725            'port: ' + repr(self.port) + ' ' +\
10726            'port_override: ' + repr(self.port_override) + ' ' +\
10727            'schema: ' + repr(self.schema) + ' ' +\
10728            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10729            'tags: ' + repr(self.tags) + ' ' +\
10730            'username: ' + repr(self.username) + ' ' +\
10731            '>'
10732
10733    def to_dict(self):
10734        return {
10735            'bind_interface': self.bind_interface,
10736            'database': self.database,
10737            'egress_filter': self.egress_filter,
10738            'healthy': self.healthy,
10739            'hostname': self.hostname,
10740            'id': self.id,
10741            'name': self.name,
10742            'override_database': self.override_database,
10743            'password': self.password,
10744            'port': self.port,
10745            'port_override': self.port_override,
10746            'schema': self.schema,
10747            'secret_store_id': self.secret_store_id,
10748            'tags': self.tags,
10749            'username': self.username,
10750        }
10751
10752    @classmethod
10753    def from_dict(cls, d):
10754        return cls(
10755            bind_interface=d.get('bind_interface'),
10756            database=d.get('database'),
10757            egress_filter=d.get('egress_filter'),
10758            healthy=d.get('healthy'),
10759            hostname=d.get('hostname'),
10760            id=d.get('id'),
10761            name=d.get('name'),
10762            override_database=d.get('override_database'),
10763            password=d.get('password'),
10764            port=d.get('port'),
10765            port_override=d.get('port_override'),
10766            schema=d.get('schema'),
10767            secret_store_id=d.get('secret_store_id'),
10768            tags=d.get('tags'),
10769            username=d.get('username'),
10770        )
SQLServer( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
10659    def __init__(
10660        self,
10661        bind_interface=None,
10662        database=None,
10663        egress_filter=None,
10664        healthy=None,
10665        hostname=None,
10666        id=None,
10667        name=None,
10668        override_database=None,
10669        password=None,
10670        port=None,
10671        port_override=None,
10672        schema=None,
10673        secret_store_id=None,
10674        tags=None,
10675        username=None,
10676    ):
10677        self.bind_interface = bind_interface if bind_interface is not None else ''
10678        '''
10679         Bind interface
10680        '''
10681        self.database = database if database is not None else ''
10682        self.egress_filter = egress_filter if egress_filter is not None else ''
10683        '''
10684         A filter applied to the routing logic to pin datasource to nodes.
10685        '''
10686        self.healthy = healthy if healthy is not None else False
10687        '''
10688         True if the datasource is reachable and the credentials are valid.
10689        '''
10690        self.hostname = hostname if hostname is not None else ''
10691        self.id = id if id is not None else ''
10692        '''
10693         Unique identifier of the Resource.
10694        '''
10695        self.name = name if name is not None else ''
10696        '''
10697         Unique human-readable name of the Resource.
10698        '''
10699        self.override_database = override_database if override_database is not None else False
10700        self.password = password if password is not None else ''
10701        self.port = port if port is not None else 0
10702        self.port_override = port_override if port_override is not None else 0
10703        self.schema = schema if schema is not None else ''
10704        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10705        '''
10706         ID of the secret store containing credentials for this resource, if any.
10707        '''
10708        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10709        '''
10710         Tags is a map of key, value pairs.
10711        '''
10712        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10733    def to_dict(self):
10734        return {
10735            'bind_interface': self.bind_interface,
10736            'database': self.database,
10737            'egress_filter': self.egress_filter,
10738            'healthy': self.healthy,
10739            'hostname': self.hostname,
10740            'id': self.id,
10741            'name': self.name,
10742            'override_database': self.override_database,
10743            'password': self.password,
10744            'port': self.port,
10745            'port_override': self.port_override,
10746            'schema': self.schema,
10747            'secret_store_id': self.secret_store_id,
10748            'tags': self.tags,
10749            'username': self.username,
10750        }
@classmethod
def from_dict(cls, d)
10752    @classmethod
10753    def from_dict(cls, d):
10754        return cls(
10755            bind_interface=d.get('bind_interface'),
10756            database=d.get('database'),
10757            egress_filter=d.get('egress_filter'),
10758            healthy=d.get('healthy'),
10759            hostname=d.get('hostname'),
10760            id=d.get('id'),
10761            name=d.get('name'),
10762            override_database=d.get('override_database'),
10763            password=d.get('password'),
10764            port=d.get('port'),
10765            port_override=d.get('port_override'),
10766            schema=d.get('schema'),
10767            secret_store_id=d.get('secret_store_id'),
10768            tags=d.get('tags'),
10769            username=d.get('username'),
10770        )
class SSH:
10773class SSH:
10774    __slots__ = [
10775        'allow_deprecated_key_exchanges',
10776        'bind_interface',
10777        'egress_filter',
10778        'healthy',
10779        'hostname',
10780        'id',
10781        'key_type',
10782        'name',
10783        'port',
10784        'port_forwarding',
10785        'port_override',
10786        'public_key',
10787        'secret_store_id',
10788        'tags',
10789        'username',
10790    ]
10791
10792    def __init__(
10793        self,
10794        allow_deprecated_key_exchanges=None,
10795        bind_interface=None,
10796        egress_filter=None,
10797        healthy=None,
10798        hostname=None,
10799        id=None,
10800        key_type=None,
10801        name=None,
10802        port=None,
10803        port_forwarding=None,
10804        port_override=None,
10805        public_key=None,
10806        secret_store_id=None,
10807        tags=None,
10808        username=None,
10809    ):
10810        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10811        self.bind_interface = bind_interface if bind_interface is not None else ''
10812        '''
10813         Bind interface
10814        '''
10815        self.egress_filter = egress_filter if egress_filter is not None else ''
10816        '''
10817         A filter applied to the routing logic to pin datasource to nodes.
10818        '''
10819        self.healthy = healthy if healthy is not None else False
10820        '''
10821         True if the datasource is reachable and the credentials are valid.
10822        '''
10823        self.hostname = hostname if hostname is not None else ''
10824        self.id = id if id is not None else ''
10825        '''
10826         Unique identifier of the Resource.
10827        '''
10828        self.key_type = key_type if key_type is not None else ''
10829        self.name = name if name is not None else ''
10830        '''
10831         Unique human-readable name of the Resource.
10832        '''
10833        self.port = port if port is not None else 0
10834        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10835        self.port_override = port_override if port_override is not None else 0
10836        self.public_key = public_key if public_key is not None else ''
10837        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10838        '''
10839         ID of the secret store containing credentials for this resource, if any.
10840        '''
10841        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10842        '''
10843         Tags is a map of key, value pairs.
10844        '''
10845        self.username = username if username is not None else ''
10846
10847    def __repr__(self):
10848        return '<sdm.SSH ' + \
10849            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10850            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10851            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10852            'healthy: ' + repr(self.healthy) + ' ' +\
10853            'hostname: ' + repr(self.hostname) + ' ' +\
10854            'id: ' + repr(self.id) + ' ' +\
10855            'key_type: ' + repr(self.key_type) + ' ' +\
10856            'name: ' + repr(self.name) + ' ' +\
10857            'port: ' + repr(self.port) + ' ' +\
10858            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10859            'port_override: ' + repr(self.port_override) + ' ' +\
10860            'public_key: ' + repr(self.public_key) + ' ' +\
10861            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10862            'tags: ' + repr(self.tags) + ' ' +\
10863            'username: ' + repr(self.username) + ' ' +\
10864            '>'
10865
10866    def to_dict(self):
10867        return {
10868            'allow_deprecated_key_exchanges':
10869            self.allow_deprecated_key_exchanges,
10870            'bind_interface': self.bind_interface,
10871            'egress_filter': self.egress_filter,
10872            'healthy': self.healthy,
10873            'hostname': self.hostname,
10874            'id': self.id,
10875            'key_type': self.key_type,
10876            'name': self.name,
10877            'port': self.port,
10878            'port_forwarding': self.port_forwarding,
10879            'port_override': self.port_override,
10880            'public_key': self.public_key,
10881            'secret_store_id': self.secret_store_id,
10882            'tags': self.tags,
10883            'username': self.username,
10884        }
10885
10886    @classmethod
10887    def from_dict(cls, d):
10888        return cls(
10889            allow_deprecated_key_exchanges=d.get(
10890                'allow_deprecated_key_exchanges'),
10891            bind_interface=d.get('bind_interface'),
10892            egress_filter=d.get('egress_filter'),
10893            healthy=d.get('healthy'),
10894            hostname=d.get('hostname'),
10895            id=d.get('id'),
10896            key_type=d.get('key_type'),
10897            name=d.get('name'),
10898            port=d.get('port'),
10899            port_forwarding=d.get('port_forwarding'),
10900            port_override=d.get('port_override'),
10901            public_key=d.get('public_key'),
10902            secret_store_id=d.get('secret_store_id'),
10903            tags=d.get('tags'),
10904            username=d.get('username'),
10905        )
SSH( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, public_key=None, secret_store_id=None, tags=None, username=None)
10792    def __init__(
10793        self,
10794        allow_deprecated_key_exchanges=None,
10795        bind_interface=None,
10796        egress_filter=None,
10797        healthy=None,
10798        hostname=None,
10799        id=None,
10800        key_type=None,
10801        name=None,
10802        port=None,
10803        port_forwarding=None,
10804        port_override=None,
10805        public_key=None,
10806        secret_store_id=None,
10807        tags=None,
10808        username=None,
10809    ):
10810        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10811        self.bind_interface = bind_interface if bind_interface is not None else ''
10812        '''
10813         Bind interface
10814        '''
10815        self.egress_filter = egress_filter if egress_filter is not None else ''
10816        '''
10817         A filter applied to the routing logic to pin datasource to nodes.
10818        '''
10819        self.healthy = healthy if healthy is not None else False
10820        '''
10821         True if the datasource is reachable and the credentials are valid.
10822        '''
10823        self.hostname = hostname if hostname is not None else ''
10824        self.id = id if id is not None else ''
10825        '''
10826         Unique identifier of the Resource.
10827        '''
10828        self.key_type = key_type if key_type is not None else ''
10829        self.name = name if name is not None else ''
10830        '''
10831         Unique human-readable name of the Resource.
10832        '''
10833        self.port = port if port is not None else 0
10834        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10835        self.port_override = port_override if port_override is not None else 0
10836        self.public_key = public_key if public_key is not None else ''
10837        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10838        '''
10839         ID of the secret store containing credentials for this resource, if any.
10840        '''
10841        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10842        '''
10843         Tags is a map of key, value pairs.
10844        '''
10845        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
public_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10866    def to_dict(self):
10867        return {
10868            'allow_deprecated_key_exchanges':
10869            self.allow_deprecated_key_exchanges,
10870            'bind_interface': self.bind_interface,
10871            'egress_filter': self.egress_filter,
10872            'healthy': self.healthy,
10873            'hostname': self.hostname,
10874            'id': self.id,
10875            'key_type': self.key_type,
10876            'name': self.name,
10877            'port': self.port,
10878            'port_forwarding': self.port_forwarding,
10879            'port_override': self.port_override,
10880            'public_key': self.public_key,
10881            'secret_store_id': self.secret_store_id,
10882            'tags': self.tags,
10883            'username': self.username,
10884        }
@classmethod
def from_dict(cls, d)
10886    @classmethod
10887    def from_dict(cls, d):
10888        return cls(
10889            allow_deprecated_key_exchanges=d.get(
10890                'allow_deprecated_key_exchanges'),
10891            bind_interface=d.get('bind_interface'),
10892            egress_filter=d.get('egress_filter'),
10893            healthy=d.get('healthy'),
10894            hostname=d.get('hostname'),
10895            id=d.get('id'),
10896            key_type=d.get('key_type'),
10897            name=d.get('name'),
10898            port=d.get('port'),
10899            port_forwarding=d.get('port_forwarding'),
10900            port_override=d.get('port_override'),
10901            public_key=d.get('public_key'),
10902            secret_store_id=d.get('secret_store_id'),
10903            tags=d.get('tags'),
10904            username=d.get('username'),
10905        )
class SSHCert:
10908class SSHCert:
10909    __slots__ = [
10910        'allow_deprecated_key_exchanges',
10911        'bind_interface',
10912        'egress_filter',
10913        'healthy',
10914        'hostname',
10915        'id',
10916        'key_type',
10917        'name',
10918        'port',
10919        'port_forwarding',
10920        'port_override',
10921        'remote_identity_group_id',
10922        'remote_identity_healthcheck_username',
10923        'secret_store_id',
10924        'tags',
10925        'username',
10926    ]
10927
10928    def __init__(
10929        self,
10930        allow_deprecated_key_exchanges=None,
10931        bind_interface=None,
10932        egress_filter=None,
10933        healthy=None,
10934        hostname=None,
10935        id=None,
10936        key_type=None,
10937        name=None,
10938        port=None,
10939        port_forwarding=None,
10940        port_override=None,
10941        remote_identity_group_id=None,
10942        remote_identity_healthcheck_username=None,
10943        secret_store_id=None,
10944        tags=None,
10945        username=None,
10946    ):
10947        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10948        self.bind_interface = bind_interface if bind_interface is not None else ''
10949        '''
10950         Bind interface
10951        '''
10952        self.egress_filter = egress_filter if egress_filter is not None else ''
10953        '''
10954         A filter applied to the routing logic to pin datasource to nodes.
10955        '''
10956        self.healthy = healthy if healthy is not None else False
10957        '''
10958         True if the datasource is reachable and the credentials are valid.
10959        '''
10960        self.hostname = hostname if hostname is not None else ''
10961        self.id = id if id is not None else ''
10962        '''
10963         Unique identifier of the Resource.
10964        '''
10965        self.key_type = key_type if key_type is not None else ''
10966        self.name = name if name is not None else ''
10967        '''
10968         Unique human-readable name of the Resource.
10969        '''
10970        self.port = port if port is not None else 0
10971        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10972        self.port_override = port_override if port_override is not None else 0
10973        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10974        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10975        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10976        '''
10977         ID of the secret store containing credentials for this resource, if any.
10978        '''
10979        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10980        '''
10981         Tags is a map of key, value pairs.
10982        '''
10983        self.username = username if username is not None else ''
10984
10985    def __repr__(self):
10986        return '<sdm.SSHCert ' + \
10987            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
10988            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10989            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10990            'healthy: ' + repr(self.healthy) + ' ' +\
10991            'hostname: ' + repr(self.hostname) + ' ' +\
10992            'id: ' + repr(self.id) + ' ' +\
10993            'key_type: ' + repr(self.key_type) + ' ' +\
10994            'name: ' + repr(self.name) + ' ' +\
10995            'port: ' + repr(self.port) + ' ' +\
10996            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
10997            'port_override: ' + repr(self.port_override) + ' ' +\
10998            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10999            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
11000            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11001            'tags: ' + repr(self.tags) + ' ' +\
11002            'username: ' + repr(self.username) + ' ' +\
11003            '>'
11004
11005    def to_dict(self):
11006        return {
11007            'allow_deprecated_key_exchanges':
11008            self.allow_deprecated_key_exchanges,
11009            'bind_interface': self.bind_interface,
11010            'egress_filter': self.egress_filter,
11011            'healthy': self.healthy,
11012            'hostname': self.hostname,
11013            'id': self.id,
11014            'key_type': self.key_type,
11015            'name': self.name,
11016            'port': self.port,
11017            'port_forwarding': self.port_forwarding,
11018            'port_override': self.port_override,
11019            'remote_identity_group_id': self.remote_identity_group_id,
11020            'remote_identity_healthcheck_username':
11021            self.remote_identity_healthcheck_username,
11022            'secret_store_id': self.secret_store_id,
11023            'tags': self.tags,
11024            'username': self.username,
11025        }
11026
11027    @classmethod
11028    def from_dict(cls, d):
11029        return cls(
11030            allow_deprecated_key_exchanges=d.get(
11031                'allow_deprecated_key_exchanges'),
11032            bind_interface=d.get('bind_interface'),
11033            egress_filter=d.get('egress_filter'),
11034            healthy=d.get('healthy'),
11035            hostname=d.get('hostname'),
11036            id=d.get('id'),
11037            key_type=d.get('key_type'),
11038            name=d.get('name'),
11039            port=d.get('port'),
11040            port_forwarding=d.get('port_forwarding'),
11041            port_override=d.get('port_override'),
11042            remote_identity_group_id=d.get('remote_identity_group_id'),
11043            remote_identity_healthcheck_username=d.get(
11044                'remote_identity_healthcheck_username'),
11045            secret_store_id=d.get('secret_store_id'),
11046            tags=d.get('tags'),
11047            username=d.get('username'),
11048        )
SSHCert( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, key_type=None, name=None, port=None, port_forwarding=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, username=None)
10928    def __init__(
10929        self,
10930        allow_deprecated_key_exchanges=None,
10931        bind_interface=None,
10932        egress_filter=None,
10933        healthy=None,
10934        hostname=None,
10935        id=None,
10936        key_type=None,
10937        name=None,
10938        port=None,
10939        port_forwarding=None,
10940        port_override=None,
10941        remote_identity_group_id=None,
10942        remote_identity_healthcheck_username=None,
10943        secret_store_id=None,
10944        tags=None,
10945        username=None,
10946    ):
10947        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
10948        self.bind_interface = bind_interface if bind_interface is not None else ''
10949        '''
10950         Bind interface
10951        '''
10952        self.egress_filter = egress_filter if egress_filter is not None else ''
10953        '''
10954         A filter applied to the routing logic to pin datasource to nodes.
10955        '''
10956        self.healthy = healthy if healthy is not None else False
10957        '''
10958         True if the datasource is reachable and the credentials are valid.
10959        '''
10960        self.hostname = hostname if hostname is not None else ''
10961        self.id = id if id is not None else ''
10962        '''
10963         Unique identifier of the Resource.
10964        '''
10965        self.key_type = key_type if key_type is not None else ''
10966        self.name = name if name is not None else ''
10967        '''
10968         Unique human-readable name of the Resource.
10969        '''
10970        self.port = port if port is not None else 0
10971        self.port_forwarding = port_forwarding if port_forwarding is not None else False
10972        self.port_override = port_override if port_override is not None else 0
10973        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10974        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
10975        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10976        '''
10977         ID of the secret store containing credentials for this resource, if any.
10978        '''
10979        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10980        '''
10981         Tags is a map of key, value pairs.
10982        '''
10983        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

key_type
name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11005    def to_dict(self):
11006        return {
11007            'allow_deprecated_key_exchanges':
11008            self.allow_deprecated_key_exchanges,
11009            'bind_interface': self.bind_interface,
11010            'egress_filter': self.egress_filter,
11011            'healthy': self.healthy,
11012            'hostname': self.hostname,
11013            'id': self.id,
11014            'key_type': self.key_type,
11015            'name': self.name,
11016            'port': self.port,
11017            'port_forwarding': self.port_forwarding,
11018            'port_override': self.port_override,
11019            'remote_identity_group_id': self.remote_identity_group_id,
11020            'remote_identity_healthcheck_username':
11021            self.remote_identity_healthcheck_username,
11022            'secret_store_id': self.secret_store_id,
11023            'tags': self.tags,
11024            'username': self.username,
11025        }
@classmethod
def from_dict(cls, d)
11027    @classmethod
11028    def from_dict(cls, d):
11029        return cls(
11030            allow_deprecated_key_exchanges=d.get(
11031                'allow_deprecated_key_exchanges'),
11032            bind_interface=d.get('bind_interface'),
11033            egress_filter=d.get('egress_filter'),
11034            healthy=d.get('healthy'),
11035            hostname=d.get('hostname'),
11036            id=d.get('id'),
11037            key_type=d.get('key_type'),
11038            name=d.get('name'),
11039            port=d.get('port'),
11040            port_forwarding=d.get('port_forwarding'),
11041            port_override=d.get('port_override'),
11042            remote_identity_group_id=d.get('remote_identity_group_id'),
11043            remote_identity_healthcheck_username=d.get(
11044                'remote_identity_healthcheck_username'),
11045            secret_store_id=d.get('secret_store_id'),
11046            tags=d.get('tags'),
11047            username=d.get('username'),
11048        )
class SSHCustomerKey:
11051class SSHCustomerKey:
11052    __slots__ = [
11053        'allow_deprecated_key_exchanges',
11054        'bind_interface',
11055        'egress_filter',
11056        'healthy',
11057        'hostname',
11058        'id',
11059        'name',
11060        'port',
11061        'port_forwarding',
11062        'port_override',
11063        'private_key',
11064        'secret_store_id',
11065        'tags',
11066        'username',
11067    ]
11068
11069    def __init__(
11070        self,
11071        allow_deprecated_key_exchanges=None,
11072        bind_interface=None,
11073        egress_filter=None,
11074        healthy=None,
11075        hostname=None,
11076        id=None,
11077        name=None,
11078        port=None,
11079        port_forwarding=None,
11080        port_override=None,
11081        private_key=None,
11082        secret_store_id=None,
11083        tags=None,
11084        username=None,
11085    ):
11086        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11087        self.bind_interface = bind_interface if bind_interface is not None else ''
11088        '''
11089         Bind interface
11090        '''
11091        self.egress_filter = egress_filter if egress_filter is not None else ''
11092        '''
11093         A filter applied to the routing logic to pin datasource to nodes.
11094        '''
11095        self.healthy = healthy if healthy is not None else False
11096        '''
11097         True if the datasource is reachable and the credentials are valid.
11098        '''
11099        self.hostname = hostname if hostname is not None else ''
11100        self.id = id if id is not None else ''
11101        '''
11102         Unique identifier of the Resource.
11103        '''
11104        self.name = name if name is not None else ''
11105        '''
11106         Unique human-readable name of the Resource.
11107        '''
11108        self.port = port if port is not None else 0
11109        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11110        self.port_override = port_override if port_override is not None else 0
11111        self.private_key = private_key if private_key is not None else ''
11112        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11113        '''
11114         ID of the secret store containing credentials for this resource, if any.
11115        '''
11116        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11117        '''
11118         Tags is a map of key, value pairs.
11119        '''
11120        self.username = username if username is not None else ''
11121
11122    def __repr__(self):
11123        return '<sdm.SSHCustomerKey ' + \
11124            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11125            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11126            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11127            'healthy: ' + repr(self.healthy) + ' ' +\
11128            'hostname: ' + repr(self.hostname) + ' ' +\
11129            'id: ' + repr(self.id) + ' ' +\
11130            'name: ' + repr(self.name) + ' ' +\
11131            'port: ' + repr(self.port) + ' ' +\
11132            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11133            'port_override: ' + repr(self.port_override) + ' ' +\
11134            'private_key: ' + repr(self.private_key) + ' ' +\
11135            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11136            'tags: ' + repr(self.tags) + ' ' +\
11137            'username: ' + repr(self.username) + ' ' +\
11138            '>'
11139
11140    def to_dict(self):
11141        return {
11142            'allow_deprecated_key_exchanges':
11143            self.allow_deprecated_key_exchanges,
11144            'bind_interface': self.bind_interface,
11145            'egress_filter': self.egress_filter,
11146            'healthy': self.healthy,
11147            'hostname': self.hostname,
11148            'id': self.id,
11149            'name': self.name,
11150            'port': self.port,
11151            'port_forwarding': self.port_forwarding,
11152            'port_override': self.port_override,
11153            'private_key': self.private_key,
11154            'secret_store_id': self.secret_store_id,
11155            'tags': self.tags,
11156            'username': self.username,
11157        }
11158
11159    @classmethod
11160    def from_dict(cls, d):
11161        return cls(
11162            allow_deprecated_key_exchanges=d.get(
11163                'allow_deprecated_key_exchanges'),
11164            bind_interface=d.get('bind_interface'),
11165            egress_filter=d.get('egress_filter'),
11166            healthy=d.get('healthy'),
11167            hostname=d.get('hostname'),
11168            id=d.get('id'),
11169            name=d.get('name'),
11170            port=d.get('port'),
11171            port_forwarding=d.get('port_forwarding'),
11172            port_override=d.get('port_override'),
11173            private_key=d.get('private_key'),
11174            secret_store_id=d.get('secret_store_id'),
11175            tags=d.get('tags'),
11176            username=d.get('username'),
11177        )
SSHCustomerKey( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, private_key=None, secret_store_id=None, tags=None, username=None)
11069    def __init__(
11070        self,
11071        allow_deprecated_key_exchanges=None,
11072        bind_interface=None,
11073        egress_filter=None,
11074        healthy=None,
11075        hostname=None,
11076        id=None,
11077        name=None,
11078        port=None,
11079        port_forwarding=None,
11080        port_override=None,
11081        private_key=None,
11082        secret_store_id=None,
11083        tags=None,
11084        username=None,
11085    ):
11086        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11087        self.bind_interface = bind_interface if bind_interface is not None else ''
11088        '''
11089         Bind interface
11090        '''
11091        self.egress_filter = egress_filter if egress_filter is not None else ''
11092        '''
11093         A filter applied to the routing logic to pin datasource to nodes.
11094        '''
11095        self.healthy = healthy if healthy is not None else False
11096        '''
11097         True if the datasource is reachable and the credentials are valid.
11098        '''
11099        self.hostname = hostname if hostname is not None else ''
11100        self.id = id if id is not None else ''
11101        '''
11102         Unique identifier of the Resource.
11103        '''
11104        self.name = name if name is not None else ''
11105        '''
11106         Unique human-readable name of the Resource.
11107        '''
11108        self.port = port if port is not None else 0
11109        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11110        self.port_override = port_override if port_override is not None else 0
11111        self.private_key = private_key if private_key is not None else ''
11112        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11113        '''
11114         ID of the secret store containing credentials for this resource, if any.
11115        '''
11116        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11117        '''
11118         Tags is a map of key, value pairs.
11119        '''
11120        self.username = username if username is not None else ''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
private_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11140    def to_dict(self):
11141        return {
11142            'allow_deprecated_key_exchanges':
11143            self.allow_deprecated_key_exchanges,
11144            'bind_interface': self.bind_interface,
11145            'egress_filter': self.egress_filter,
11146            'healthy': self.healthy,
11147            'hostname': self.hostname,
11148            'id': self.id,
11149            'name': self.name,
11150            'port': self.port,
11151            'port_forwarding': self.port_forwarding,
11152            'port_override': self.port_override,
11153            'private_key': self.private_key,
11154            'secret_store_id': self.secret_store_id,
11155            'tags': self.tags,
11156            'username': self.username,
11157        }
@classmethod
def from_dict(cls, d)
11159    @classmethod
11160    def from_dict(cls, d):
11161        return cls(
11162            allow_deprecated_key_exchanges=d.get(
11163                'allow_deprecated_key_exchanges'),
11164            bind_interface=d.get('bind_interface'),
11165            egress_filter=d.get('egress_filter'),
11166            healthy=d.get('healthy'),
11167            hostname=d.get('hostname'),
11168            id=d.get('id'),
11169            name=d.get('name'),
11170            port=d.get('port'),
11171            port_forwarding=d.get('port_forwarding'),
11172            port_override=d.get('port_override'),
11173            private_key=d.get('private_key'),
11174            secret_store_id=d.get('secret_store_id'),
11175            tags=d.get('tags'),
11176            username=d.get('username'),
11177        )
class SecretStoreCreateResponse:
11180class SecretStoreCreateResponse:
11181    '''
11182         SecretStoreCreateResponse reports how the SecretStores were created in the system.
11183    '''
11184    __slots__ = [
11185        'meta',
11186        'rate_limit',
11187        'secret_store',
11188    ]
11189
11190    def __init__(
11191        self,
11192        meta=None,
11193        rate_limit=None,
11194        secret_store=None,
11195    ):
11196        self.meta = meta if meta is not None else None
11197        '''
11198         Reserved for future use.
11199        '''
11200        self.rate_limit = rate_limit if rate_limit is not None else None
11201        '''
11202         Rate limit information.
11203        '''
11204        self.secret_store = secret_store if secret_store is not None else None
11205        '''
11206         The created SecretStore.
11207        '''
11208
11209    def __repr__(self):
11210        return '<sdm.SecretStoreCreateResponse ' + \
11211            'meta: ' + repr(self.meta) + ' ' +\
11212            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11213            'secret_store: ' + repr(self.secret_store) + ' ' +\
11214            '>'
11215
11216    def to_dict(self):
11217        return {
11218            'meta': self.meta,
11219            'rate_limit': self.rate_limit,
11220            'secret_store': self.secret_store,
11221        }
11222
11223    @classmethod
11224    def from_dict(cls, d):
11225        return cls(
11226            meta=d.get('meta'),
11227            rate_limit=d.get('rate_limit'),
11228            secret_store=d.get('secret_store'),
11229        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
11190    def __init__(
11191        self,
11192        meta=None,
11193        rate_limit=None,
11194        secret_store=None,
11195    ):
11196        self.meta = meta if meta is not None else None
11197        '''
11198         Reserved for future use.
11199        '''
11200        self.rate_limit = rate_limit if rate_limit is not None else None
11201        '''
11202         Rate limit information.
11203        '''
11204        self.secret_store = secret_store if secret_store is not None else None
11205        '''
11206         The created SecretStore.
11207        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The created SecretStore.

def to_dict(self)
11216    def to_dict(self):
11217        return {
11218            'meta': self.meta,
11219            'rate_limit': self.rate_limit,
11220            'secret_store': self.secret_store,
11221        }
@classmethod
def from_dict(cls, d)
11223    @classmethod
11224    def from_dict(cls, d):
11225        return cls(
11226            meta=d.get('meta'),
11227            rate_limit=d.get('rate_limit'),
11228            secret_store=d.get('secret_store'),
11229        )
class SecretStoreDeleteResponse:
11232class SecretStoreDeleteResponse:
11233    '''
11234         SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
11235    '''
11236    __slots__ = [
11237        'meta',
11238        'rate_limit',
11239    ]
11240
11241    def __init__(
11242        self,
11243        meta=None,
11244        rate_limit=None,
11245    ):
11246        self.meta = meta if meta is not None else None
11247        '''
11248         Reserved for future use.
11249        '''
11250        self.rate_limit = rate_limit if rate_limit is not None else None
11251        '''
11252         Rate limit information.
11253        '''
11254
11255    def __repr__(self):
11256        return '<sdm.SecretStoreDeleteResponse ' + \
11257            'meta: ' + repr(self.meta) + ' ' +\
11258            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11259            '>'
11260
11261    def to_dict(self):
11262        return {
11263            'meta': self.meta,
11264            'rate_limit': self.rate_limit,
11265        }
11266
11267    @classmethod
11268    def from_dict(cls, d):
11269        return cls(
11270            meta=d.get('meta'),
11271            rate_limit=d.get('rate_limit'),
11272        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

SecretStoreDeleteResponse(meta=None, rate_limit=None)
11241    def __init__(
11242        self,
11243        meta=None,
11244        rate_limit=None,
11245    ):
11246        self.meta = meta if meta is not None else None
11247        '''
11248         Reserved for future use.
11249        '''
11250        self.rate_limit = rate_limit if rate_limit is not None else None
11251        '''
11252         Rate limit information.
11253        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11261    def to_dict(self):
11262        return {
11263            'meta': self.meta,
11264            'rate_limit': self.rate_limit,
11265        }
@classmethod
def from_dict(cls, d)
11267    @classmethod
11268    def from_dict(cls, d):
11269        return cls(
11270            meta=d.get('meta'),
11271            rate_limit=d.get('rate_limit'),
11272        )
class SecretStoreGetResponse:
11275class SecretStoreGetResponse:
11276    '''
11277         SecretStoreGetResponse returns a requested SecretStore.
11278    '''
11279    __slots__ = [
11280        'meta',
11281        'rate_limit',
11282        'secret_store',
11283    ]
11284
11285    def __init__(
11286        self,
11287        meta=None,
11288        rate_limit=None,
11289        secret_store=None,
11290    ):
11291        self.meta = meta if meta is not None else None
11292        '''
11293         Reserved for future use.
11294        '''
11295        self.rate_limit = rate_limit if rate_limit is not None else None
11296        '''
11297         Rate limit information.
11298        '''
11299        self.secret_store = secret_store if secret_store is not None else None
11300        '''
11301         The requested SecretStore.
11302        '''
11303
11304    def __repr__(self):
11305        return '<sdm.SecretStoreGetResponse ' + \
11306            'meta: ' + repr(self.meta) + ' ' +\
11307            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11308            'secret_store: ' + repr(self.secret_store) + ' ' +\
11309            '>'
11310
11311    def to_dict(self):
11312        return {
11313            'meta': self.meta,
11314            'rate_limit': self.rate_limit,
11315            'secret_store': self.secret_store,
11316        }
11317
11318    @classmethod
11319    def from_dict(cls, d):
11320        return cls(
11321            meta=d.get('meta'),
11322            rate_limit=d.get('rate_limit'),
11323            secret_store=d.get('secret_store'),
11324        )

SecretStoreGetResponse returns a requested SecretStore.

SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
11285    def __init__(
11286        self,
11287        meta=None,
11288        rate_limit=None,
11289        secret_store=None,
11290    ):
11291        self.meta = meta if meta is not None else None
11292        '''
11293         Reserved for future use.
11294        '''
11295        self.rate_limit = rate_limit if rate_limit is not None else None
11296        '''
11297         Rate limit information.
11298        '''
11299        self.secret_store = secret_store if secret_store is not None else None
11300        '''
11301         The requested SecretStore.
11302        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The requested SecretStore.

def to_dict(self)
11311    def to_dict(self):
11312        return {
11313            'meta': self.meta,
11314            'rate_limit': self.rate_limit,
11315            'secret_store': self.secret_store,
11316        }
@classmethod
def from_dict(cls, d)
11318    @classmethod
11319    def from_dict(cls, d):
11320        return cls(
11321            meta=d.get('meta'),
11322            rate_limit=d.get('rate_limit'),
11323            secret_store=d.get('secret_store'),
11324        )
class SecretStoreUpdateResponse:
11327class SecretStoreUpdateResponse:
11328    '''
11329         SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
11330     a SecretStoreUpdateRequest.
11331    '''
11332    __slots__ = [
11333        'meta',
11334        'rate_limit',
11335        'secret_store',
11336    ]
11337
11338    def __init__(
11339        self,
11340        meta=None,
11341        rate_limit=None,
11342        secret_store=None,
11343    ):
11344        self.meta = meta if meta is not None else None
11345        '''
11346         Reserved for future use.
11347        '''
11348        self.rate_limit = rate_limit if rate_limit is not None else None
11349        '''
11350         Rate limit information.
11351        '''
11352        self.secret_store = secret_store if secret_store is not None else None
11353        '''
11354         The updated SecretStore.
11355        '''
11356
11357    def __repr__(self):
11358        return '<sdm.SecretStoreUpdateResponse ' + \
11359            'meta: ' + repr(self.meta) + ' ' +\
11360            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11361            'secret_store: ' + repr(self.secret_store) + ' ' +\
11362            '>'
11363
11364    def to_dict(self):
11365        return {
11366            'meta': self.meta,
11367            'rate_limit': self.rate_limit,
11368            'secret_store': self.secret_store,
11369        }
11370
11371    @classmethod
11372    def from_dict(cls, d):
11373        return cls(
11374            meta=d.get('meta'),
11375            rate_limit=d.get('rate_limit'),
11376            secret_store=d.get('secret_store'),
11377        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
11338    def __init__(
11339        self,
11340        meta=None,
11341        rate_limit=None,
11342        secret_store=None,
11343    ):
11344        self.meta = meta if meta is not None else None
11345        '''
11346         Reserved for future use.
11347        '''
11348        self.rate_limit = rate_limit if rate_limit is not None else None
11349        '''
11350         Rate limit information.
11351        '''
11352        self.secret_store = secret_store if secret_store is not None else None
11353        '''
11354         The updated SecretStore.
11355        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The updated SecretStore.

def to_dict(self)
11364    def to_dict(self):
11365        return {
11366            'meta': self.meta,
11367            'rate_limit': self.rate_limit,
11368            'secret_store': self.secret_store,
11369        }
@classmethod
def from_dict(cls, d)
11371    @classmethod
11372    def from_dict(cls, d):
11373        return cls(
11374            meta=d.get('meta'),
11375            rate_limit=d.get('rate_limit'),
11376            secret_store=d.get('secret_store'),
11377        )
class Service:
11380class Service:
11381    '''
11382         A Service is a service account that can connect to resources they are granted
11383     directly, or granted via roles. Services are typically automated jobs.
11384    '''
11385    __slots__ = [
11386        'id',
11387        'name',
11388        'suspended',
11389        'tags',
11390    ]
11391
11392    def __init__(
11393        self,
11394        id=None,
11395        name=None,
11396        suspended=None,
11397        tags=None,
11398    ):
11399        self.id = id if id is not None else ''
11400        '''
11401         Unique identifier of the Service.
11402        '''
11403        self.name = name if name is not None else ''
11404        '''
11405         Unique human-readable name of the Service.
11406        '''
11407        self.suspended = suspended if suspended is not None else False
11408        '''
11409         The Service's suspended state.
11410        '''
11411        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11412        '''
11413         Tags is a map of key, value pairs.
11414        '''
11415
11416    def __repr__(self):
11417        return '<sdm.Service ' + \
11418            'id: ' + repr(self.id) + ' ' +\
11419            'name: ' + repr(self.name) + ' ' +\
11420            'suspended: ' + repr(self.suspended) + ' ' +\
11421            'tags: ' + repr(self.tags) + ' ' +\
11422            '>'
11423
11424    def to_dict(self):
11425        return {
11426            'id': self.id,
11427            'name': self.name,
11428            'suspended': self.suspended,
11429            'tags': self.tags,
11430        }
11431
11432    @classmethod
11433    def from_dict(cls, d):
11434        return cls(
11435            id=d.get('id'),
11436            name=d.get('name'),
11437            suspended=d.get('suspended'),
11438            tags=d.get('tags'),
11439        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

Service(id=None, name=None, suspended=None, tags=None)
11392    def __init__(
11393        self,
11394        id=None,
11395        name=None,
11396        suspended=None,
11397        tags=None,
11398    ):
11399        self.id = id if id is not None else ''
11400        '''
11401         Unique identifier of the Service.
11402        '''
11403        self.name = name if name is not None else ''
11404        '''
11405         Unique human-readable name of the Service.
11406        '''
11407        self.suspended = suspended if suspended is not None else False
11408        '''
11409         The Service's suspended state.
11410        '''
11411        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11412        '''
11413         Tags is a map of key, value pairs.
11414        '''
id

Unique identifier of the Service.

name

Unique human-readable name of the Service.

suspended

The Service's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
11424    def to_dict(self):
11425        return {
11426            'id': self.id,
11427            'name': self.name,
11428            'suspended': self.suspended,
11429            'tags': self.tags,
11430        }
@classmethod
def from_dict(cls, d)
11432    @classmethod
11433    def from_dict(cls, d):
11434        return cls(
11435            id=d.get('id'),
11436            name=d.get('name'),
11437            suspended=d.get('suspended'),
11438            tags=d.get('tags'),
11439        )
class SingleStore:
11442class SingleStore:
11443    __slots__ = [
11444        'bind_interface',
11445        'database',
11446        'egress_filter',
11447        'healthy',
11448        'hostname',
11449        'id',
11450        'name',
11451        'password',
11452        'port',
11453        'port_override',
11454        'secret_store_id',
11455        'tags',
11456        'username',
11457    ]
11458
11459    def __init__(
11460        self,
11461        bind_interface=None,
11462        database=None,
11463        egress_filter=None,
11464        healthy=None,
11465        hostname=None,
11466        id=None,
11467        name=None,
11468        password=None,
11469        port=None,
11470        port_override=None,
11471        secret_store_id=None,
11472        tags=None,
11473        username=None,
11474    ):
11475        self.bind_interface = bind_interface if bind_interface is not None else ''
11476        '''
11477         Bind interface
11478        '''
11479        self.database = database if database is not None else ''
11480        self.egress_filter = egress_filter if egress_filter is not None else ''
11481        '''
11482         A filter applied to the routing logic to pin datasource to nodes.
11483        '''
11484        self.healthy = healthy if healthy is not None else False
11485        '''
11486         True if the datasource is reachable and the credentials are valid.
11487        '''
11488        self.hostname = hostname if hostname is not None else ''
11489        self.id = id if id is not None else ''
11490        '''
11491         Unique identifier of the Resource.
11492        '''
11493        self.name = name if name is not None else ''
11494        '''
11495         Unique human-readable name of the Resource.
11496        '''
11497        self.password = password if password is not None else ''
11498        self.port = port if port is not None else 0
11499        self.port_override = port_override if port_override is not None else 0
11500        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11501        '''
11502         ID of the secret store containing credentials for this resource, if any.
11503        '''
11504        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11505        '''
11506         Tags is a map of key, value pairs.
11507        '''
11508        self.username = username if username is not None else ''
11509
11510    def __repr__(self):
11511        return '<sdm.SingleStore ' + \
11512            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11513            'database: ' + repr(self.database) + ' ' +\
11514            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11515            'healthy: ' + repr(self.healthy) + ' ' +\
11516            'hostname: ' + repr(self.hostname) + ' ' +\
11517            'id: ' + repr(self.id) + ' ' +\
11518            'name: ' + repr(self.name) + ' ' +\
11519            'password: ' + repr(self.password) + ' ' +\
11520            'port: ' + repr(self.port) + ' ' +\
11521            'port_override: ' + repr(self.port_override) + ' ' +\
11522            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11523            'tags: ' + repr(self.tags) + ' ' +\
11524            'username: ' + repr(self.username) + ' ' +\
11525            '>'
11526
11527    def to_dict(self):
11528        return {
11529            'bind_interface': self.bind_interface,
11530            'database': self.database,
11531            'egress_filter': self.egress_filter,
11532            'healthy': self.healthy,
11533            'hostname': self.hostname,
11534            'id': self.id,
11535            'name': self.name,
11536            'password': self.password,
11537            'port': self.port,
11538            'port_override': self.port_override,
11539            'secret_store_id': self.secret_store_id,
11540            'tags': self.tags,
11541            'username': self.username,
11542        }
11543
11544    @classmethod
11545    def from_dict(cls, d):
11546        return cls(
11547            bind_interface=d.get('bind_interface'),
11548            database=d.get('database'),
11549            egress_filter=d.get('egress_filter'),
11550            healthy=d.get('healthy'),
11551            hostname=d.get('hostname'),
11552            id=d.get('id'),
11553            name=d.get('name'),
11554            password=d.get('password'),
11555            port=d.get('port'),
11556            port_override=d.get('port_override'),
11557            secret_store_id=d.get('secret_store_id'),
11558            tags=d.get('tags'),
11559            username=d.get('username'),
11560        )
SingleStore( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11459    def __init__(
11460        self,
11461        bind_interface=None,
11462        database=None,
11463        egress_filter=None,
11464        healthy=None,
11465        hostname=None,
11466        id=None,
11467        name=None,
11468        password=None,
11469        port=None,
11470        port_override=None,
11471        secret_store_id=None,
11472        tags=None,
11473        username=None,
11474    ):
11475        self.bind_interface = bind_interface if bind_interface is not None else ''
11476        '''
11477         Bind interface
11478        '''
11479        self.database = database if database is not None else ''
11480        self.egress_filter = egress_filter if egress_filter is not None else ''
11481        '''
11482         A filter applied to the routing logic to pin datasource to nodes.
11483        '''
11484        self.healthy = healthy if healthy is not None else False
11485        '''
11486         True if the datasource is reachable and the credentials are valid.
11487        '''
11488        self.hostname = hostname if hostname is not None else ''
11489        self.id = id if id is not None else ''
11490        '''
11491         Unique identifier of the Resource.
11492        '''
11493        self.name = name if name is not None else ''
11494        '''
11495         Unique human-readable name of the Resource.
11496        '''
11497        self.password = password if password is not None else ''
11498        self.port = port if port is not None else 0
11499        self.port_override = port_override if port_override is not None else 0
11500        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11501        '''
11502         ID of the secret store containing credentials for this resource, if any.
11503        '''
11504        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11505        '''
11506         Tags is a map of key, value pairs.
11507        '''
11508        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11527    def to_dict(self):
11528        return {
11529            'bind_interface': self.bind_interface,
11530            'database': self.database,
11531            'egress_filter': self.egress_filter,
11532            'healthy': self.healthy,
11533            'hostname': self.hostname,
11534            'id': self.id,
11535            'name': self.name,
11536            'password': self.password,
11537            'port': self.port,
11538            'port_override': self.port_override,
11539            'secret_store_id': self.secret_store_id,
11540            'tags': self.tags,
11541            'username': self.username,
11542        }
@classmethod
def from_dict(cls, d)
11544    @classmethod
11545    def from_dict(cls, d):
11546        return cls(
11547            bind_interface=d.get('bind_interface'),
11548            database=d.get('database'),
11549            egress_filter=d.get('egress_filter'),
11550            healthy=d.get('healthy'),
11551            hostname=d.get('hostname'),
11552            id=d.get('id'),
11553            name=d.get('name'),
11554            password=d.get('password'),
11555            port=d.get('port'),
11556            port_override=d.get('port_override'),
11557            secret_store_id=d.get('secret_store_id'),
11558            tags=d.get('tags'),
11559            username=d.get('username'),
11560        )
class Snowflake:
11563class Snowflake:
11564    __slots__ = [
11565        'bind_interface',
11566        'database',
11567        'egress_filter',
11568        'healthy',
11569        'hostname',
11570        'id',
11571        'name',
11572        'password',
11573        'port_override',
11574        'schema',
11575        'secret_store_id',
11576        'tags',
11577        'username',
11578    ]
11579
11580    def __init__(
11581        self,
11582        bind_interface=None,
11583        database=None,
11584        egress_filter=None,
11585        healthy=None,
11586        hostname=None,
11587        id=None,
11588        name=None,
11589        password=None,
11590        port_override=None,
11591        schema=None,
11592        secret_store_id=None,
11593        tags=None,
11594        username=None,
11595    ):
11596        self.bind_interface = bind_interface if bind_interface is not None else ''
11597        '''
11598         Bind interface
11599        '''
11600        self.database = database if database is not None else ''
11601        self.egress_filter = egress_filter if egress_filter is not None else ''
11602        '''
11603         A filter applied to the routing logic to pin datasource to nodes.
11604        '''
11605        self.healthy = healthy if healthy is not None else False
11606        '''
11607         True if the datasource is reachable and the credentials are valid.
11608        '''
11609        self.hostname = hostname if hostname is not None else ''
11610        self.id = id if id is not None else ''
11611        '''
11612         Unique identifier of the Resource.
11613        '''
11614        self.name = name if name is not None else ''
11615        '''
11616         Unique human-readable name of the Resource.
11617        '''
11618        self.password = password if password is not None else ''
11619        self.port_override = port_override if port_override is not None else 0
11620        self.schema = schema if schema is not None else ''
11621        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11622        '''
11623         ID of the secret store containing credentials for this resource, if any.
11624        '''
11625        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11626        '''
11627         Tags is a map of key, value pairs.
11628        '''
11629        self.username = username if username is not None else ''
11630
11631    def __repr__(self):
11632        return '<sdm.Snowflake ' + \
11633            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11634            'database: ' + repr(self.database) + ' ' +\
11635            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11636            'healthy: ' + repr(self.healthy) + ' ' +\
11637            'hostname: ' + repr(self.hostname) + ' ' +\
11638            'id: ' + repr(self.id) + ' ' +\
11639            'name: ' + repr(self.name) + ' ' +\
11640            'password: ' + repr(self.password) + ' ' +\
11641            'port_override: ' + repr(self.port_override) + ' ' +\
11642            'schema: ' + repr(self.schema) + ' ' +\
11643            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11644            'tags: ' + repr(self.tags) + ' ' +\
11645            'username: ' + repr(self.username) + ' ' +\
11646            '>'
11647
11648    def to_dict(self):
11649        return {
11650            'bind_interface': self.bind_interface,
11651            'database': self.database,
11652            'egress_filter': self.egress_filter,
11653            'healthy': self.healthy,
11654            'hostname': self.hostname,
11655            'id': self.id,
11656            'name': self.name,
11657            'password': self.password,
11658            'port_override': self.port_override,
11659            'schema': self.schema,
11660            'secret_store_id': self.secret_store_id,
11661            'tags': self.tags,
11662            'username': self.username,
11663        }
11664
11665    @classmethod
11666    def from_dict(cls, d):
11667        return cls(
11668            bind_interface=d.get('bind_interface'),
11669            database=d.get('database'),
11670            egress_filter=d.get('egress_filter'),
11671            healthy=d.get('healthy'),
11672            hostname=d.get('hostname'),
11673            id=d.get('id'),
11674            name=d.get('name'),
11675            password=d.get('password'),
11676            port_override=d.get('port_override'),
11677            schema=d.get('schema'),
11678            secret_store_id=d.get('secret_store_id'),
11679            tags=d.get('tags'),
11680            username=d.get('username'),
11681        )
Snowflake( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
11580    def __init__(
11581        self,
11582        bind_interface=None,
11583        database=None,
11584        egress_filter=None,
11585        healthy=None,
11586        hostname=None,
11587        id=None,
11588        name=None,
11589        password=None,
11590        port_override=None,
11591        schema=None,
11592        secret_store_id=None,
11593        tags=None,
11594        username=None,
11595    ):
11596        self.bind_interface = bind_interface if bind_interface is not None else ''
11597        '''
11598         Bind interface
11599        '''
11600        self.database = database if database is not None else ''
11601        self.egress_filter = egress_filter if egress_filter is not None else ''
11602        '''
11603         A filter applied to the routing logic to pin datasource to nodes.
11604        '''
11605        self.healthy = healthy if healthy is not None else False
11606        '''
11607         True if the datasource is reachable and the credentials are valid.
11608        '''
11609        self.hostname = hostname if hostname is not None else ''
11610        self.id = id if id is not None else ''
11611        '''
11612         Unique identifier of the Resource.
11613        '''
11614        self.name = name if name is not None else ''
11615        '''
11616         Unique human-readable name of the Resource.
11617        '''
11618        self.password = password if password is not None else ''
11619        self.port_override = port_override if port_override is not None else 0
11620        self.schema = schema if schema is not None else ''
11621        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11622        '''
11623         ID of the secret store containing credentials for this resource, if any.
11624        '''
11625        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11626        '''
11627         Tags is a map of key, value pairs.
11628        '''
11629        self.username = username if username is not None else ''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11648    def to_dict(self):
11649        return {
11650            'bind_interface': self.bind_interface,
11651            'database': self.database,
11652            'egress_filter': self.egress_filter,
11653            'healthy': self.healthy,
11654            'hostname': self.hostname,
11655            'id': self.id,
11656            'name': self.name,
11657            'password': self.password,
11658            'port_override': self.port_override,
11659            'schema': self.schema,
11660            'secret_store_id': self.secret_store_id,
11661            'tags': self.tags,
11662            'username': self.username,
11663        }
@classmethod
def from_dict(cls, d)
11665    @classmethod
11666    def from_dict(cls, d):
11667        return cls(
11668            bind_interface=d.get('bind_interface'),
11669            database=d.get('database'),
11670            egress_filter=d.get('egress_filter'),
11671            healthy=d.get('healthy'),
11672            hostname=d.get('hostname'),
11673            id=d.get('id'),
11674            name=d.get('name'),
11675            password=d.get('password'),
11676            port_override=d.get('port_override'),
11677            schema=d.get('schema'),
11678            secret_store_id=d.get('secret_store_id'),
11679            tags=d.get('tags'),
11680            username=d.get('username'),
11681        )
class Snowsight:
11684class Snowsight:
11685    '''
11686    Snowsight is currently unstable, and its API may change, or it may be removed,
11687    without a major version bump.
11688    '''
11689    __slots__ = [
11690        'bind_interface',
11691        'egress_filter',
11692        'healthcheck_username',
11693        'healthy',
11694        'id',
11695        'name',
11696        'port_override',
11697        'samlmetadata',
11698        'secret_store_id',
11699        'subdomain',
11700        'tags',
11701    ]
11702
11703    def __init__(
11704        self,
11705        bind_interface=None,
11706        egress_filter=None,
11707        healthcheck_username=None,
11708        healthy=None,
11709        id=None,
11710        name=None,
11711        port_override=None,
11712        samlmetadata=None,
11713        secret_store_id=None,
11714        subdomain=None,
11715        tags=None,
11716    ):
11717        self.bind_interface = bind_interface if bind_interface is not None else ''
11718        '''
11719         Bind interface
11720        '''
11721        self.egress_filter = egress_filter if egress_filter is not None else ''
11722        '''
11723         A filter applied to the routing logic to pin datasource to nodes.
11724        '''
11725        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11726        self.healthy = healthy if healthy is not None else False
11727        '''
11728         True if the datasource is reachable and the credentials are valid.
11729        '''
11730        self.id = id if id is not None else ''
11731        '''
11732         Unique identifier of the Resource.
11733        '''
11734        self.name = name if name is not None else ''
11735        '''
11736         Unique human-readable name of the Resource.
11737        '''
11738        self.port_override = port_override if port_override is not None else 0
11739        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11740        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11741        '''
11742         ID of the secret store containing credentials for this resource, if any.
11743        '''
11744        self.subdomain = subdomain if subdomain is not None else ''
11745        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11746        '''
11747         Tags is a map of key, value pairs.
11748        '''
11749
11750    def __repr__(self):
11751        return '<sdm.Snowsight ' + \
11752            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11753            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11754            'healthcheck_username: ' + repr(self.healthcheck_username) + ' ' +\
11755            'healthy: ' + repr(self.healthy) + ' ' +\
11756            'id: ' + repr(self.id) + ' ' +\
11757            'name: ' + repr(self.name) + ' ' +\
11758            'port_override: ' + repr(self.port_override) + ' ' +\
11759            'samlmetadata: ' + repr(self.samlmetadata) + ' ' +\
11760            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11761            'subdomain: ' + repr(self.subdomain) + ' ' +\
11762            'tags: ' + repr(self.tags) + ' ' +\
11763            '>'
11764
11765    def to_dict(self):
11766        return {
11767            'bind_interface': self.bind_interface,
11768            'egress_filter': self.egress_filter,
11769            'healthcheck_username': self.healthcheck_username,
11770            'healthy': self.healthy,
11771            'id': self.id,
11772            'name': self.name,
11773            'port_override': self.port_override,
11774            'samlmetadata': self.samlmetadata,
11775            'secret_store_id': self.secret_store_id,
11776            'subdomain': self.subdomain,
11777            'tags': self.tags,
11778        }
11779
11780    @classmethod
11781    def from_dict(cls, d):
11782        return cls(
11783            bind_interface=d.get('bind_interface'),
11784            egress_filter=d.get('egress_filter'),
11785            healthcheck_username=d.get('healthcheck_username'),
11786            healthy=d.get('healthy'),
11787            id=d.get('id'),
11788            name=d.get('name'),
11789            port_override=d.get('port_override'),
11790            samlmetadata=d.get('samlmetadata'),
11791            secret_store_id=d.get('secret_store_id'),
11792            subdomain=d.get('subdomain'),
11793            tags=d.get('tags'),
11794        )

Snowsight is currently unstable, and its API may change, or it may be removed, without a major version bump.

Snowsight( bind_interface=None, egress_filter=None, healthcheck_username=None, healthy=None, id=None, name=None, port_override=None, samlmetadata=None, secret_store_id=None, subdomain=None, tags=None)
11703    def __init__(
11704        self,
11705        bind_interface=None,
11706        egress_filter=None,
11707        healthcheck_username=None,
11708        healthy=None,
11709        id=None,
11710        name=None,
11711        port_override=None,
11712        samlmetadata=None,
11713        secret_store_id=None,
11714        subdomain=None,
11715        tags=None,
11716    ):
11717        self.bind_interface = bind_interface if bind_interface is not None else ''
11718        '''
11719         Bind interface
11720        '''
11721        self.egress_filter = egress_filter if egress_filter is not None else ''
11722        '''
11723         A filter applied to the routing logic to pin datasource to nodes.
11724        '''
11725        self.healthcheck_username = healthcheck_username if healthcheck_username is not None else ''
11726        self.healthy = healthy if healthy is not None else False
11727        '''
11728         True if the datasource is reachable and the credentials are valid.
11729        '''
11730        self.id = id if id is not None else ''
11731        '''
11732         Unique identifier of the Resource.
11733        '''
11734        self.name = name if name is not None else ''
11735        '''
11736         Unique human-readable name of the Resource.
11737        '''
11738        self.port_override = port_override if port_override is not None else 0
11739        self.samlmetadata = samlmetadata if samlmetadata is not None else ''
11740        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11741        '''
11742         ID of the secret store containing credentials for this resource, if any.
11743        '''
11744        self.subdomain = subdomain if subdomain is not None else ''
11745        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11746        '''
11747         Tags is a map of key, value pairs.
11748        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_username
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
samlmetadata
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

def to_dict(self)
11765    def to_dict(self):
11766        return {
11767            'bind_interface': self.bind_interface,
11768            'egress_filter': self.egress_filter,
11769            'healthcheck_username': self.healthcheck_username,
11770            'healthy': self.healthy,
11771            'id': self.id,
11772            'name': self.name,
11773            'port_override': self.port_override,
11774            'samlmetadata': self.samlmetadata,
11775            'secret_store_id': self.secret_store_id,
11776            'subdomain': self.subdomain,
11777            'tags': self.tags,
11778        }
@classmethod
def from_dict(cls, d)
11780    @classmethod
11781    def from_dict(cls, d):
11782        return cls(
11783            bind_interface=d.get('bind_interface'),
11784            egress_filter=d.get('egress_filter'),
11785            healthcheck_username=d.get('healthcheck_username'),
11786            healthy=d.get('healthy'),
11787            id=d.get('id'),
11788            name=d.get('name'),
11789            port_override=d.get('port_override'),
11790            samlmetadata=d.get('samlmetadata'),
11791            secret_store_id=d.get('secret_store_id'),
11792            subdomain=d.get('subdomain'),
11793            tags=d.get('tags'),
11794        )
class Sybase:
11797class Sybase:
11798    __slots__ = [
11799        'bind_interface',
11800        'egress_filter',
11801        'healthy',
11802        'hostname',
11803        'id',
11804        'name',
11805        'password',
11806        'port',
11807        'port_override',
11808        'secret_store_id',
11809        'tags',
11810        'username',
11811    ]
11812
11813    def __init__(
11814        self,
11815        bind_interface=None,
11816        egress_filter=None,
11817        healthy=None,
11818        hostname=None,
11819        id=None,
11820        name=None,
11821        password=None,
11822        port=None,
11823        port_override=None,
11824        secret_store_id=None,
11825        tags=None,
11826        username=None,
11827    ):
11828        self.bind_interface = bind_interface if bind_interface is not None else ''
11829        '''
11830         Bind interface
11831        '''
11832        self.egress_filter = egress_filter if egress_filter is not None else ''
11833        '''
11834         A filter applied to the routing logic to pin datasource to nodes.
11835        '''
11836        self.healthy = healthy if healthy is not None else False
11837        '''
11838         True if the datasource is reachable and the credentials are valid.
11839        '''
11840        self.hostname = hostname if hostname is not None else ''
11841        self.id = id if id is not None else ''
11842        '''
11843         Unique identifier of the Resource.
11844        '''
11845        self.name = name if name is not None else ''
11846        '''
11847         Unique human-readable name of the Resource.
11848        '''
11849        self.password = password if password is not None else ''
11850        self.port = port if port is not None else 0
11851        self.port_override = port_override if port_override is not None else 0
11852        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11853        '''
11854         ID of the secret store containing credentials for this resource, if any.
11855        '''
11856        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11857        '''
11858         Tags is a map of key, value pairs.
11859        '''
11860        self.username = username if username is not None else ''
11861
11862    def __repr__(self):
11863        return '<sdm.Sybase ' + \
11864            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11865            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11866            'healthy: ' + repr(self.healthy) + ' ' +\
11867            'hostname: ' + repr(self.hostname) + ' ' +\
11868            'id: ' + repr(self.id) + ' ' +\
11869            'name: ' + repr(self.name) + ' ' +\
11870            'password: ' + repr(self.password) + ' ' +\
11871            'port: ' + repr(self.port) + ' ' +\
11872            'port_override: ' + repr(self.port_override) + ' ' +\
11873            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11874            'tags: ' + repr(self.tags) + ' ' +\
11875            'username: ' + repr(self.username) + ' ' +\
11876            '>'
11877
11878    def to_dict(self):
11879        return {
11880            'bind_interface': self.bind_interface,
11881            'egress_filter': self.egress_filter,
11882            'healthy': self.healthy,
11883            'hostname': self.hostname,
11884            'id': self.id,
11885            'name': self.name,
11886            'password': self.password,
11887            'port': self.port,
11888            'port_override': self.port_override,
11889            'secret_store_id': self.secret_store_id,
11890            'tags': self.tags,
11891            'username': self.username,
11892        }
11893
11894    @classmethod
11895    def from_dict(cls, d):
11896        return cls(
11897            bind_interface=d.get('bind_interface'),
11898            egress_filter=d.get('egress_filter'),
11899            healthy=d.get('healthy'),
11900            hostname=d.get('hostname'),
11901            id=d.get('id'),
11902            name=d.get('name'),
11903            password=d.get('password'),
11904            port=d.get('port'),
11905            port_override=d.get('port_override'),
11906            secret_store_id=d.get('secret_store_id'),
11907            tags=d.get('tags'),
11908            username=d.get('username'),
11909        )
Sybase( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11813    def __init__(
11814        self,
11815        bind_interface=None,
11816        egress_filter=None,
11817        healthy=None,
11818        hostname=None,
11819        id=None,
11820        name=None,
11821        password=None,
11822        port=None,
11823        port_override=None,
11824        secret_store_id=None,
11825        tags=None,
11826        username=None,
11827    ):
11828        self.bind_interface = bind_interface if bind_interface is not None else ''
11829        '''
11830         Bind interface
11831        '''
11832        self.egress_filter = egress_filter if egress_filter is not None else ''
11833        '''
11834         A filter applied to the routing logic to pin datasource to nodes.
11835        '''
11836        self.healthy = healthy if healthy is not None else False
11837        '''
11838         True if the datasource is reachable and the credentials are valid.
11839        '''
11840        self.hostname = hostname if hostname is not None else ''
11841        self.id = id if id is not None else ''
11842        '''
11843         Unique identifier of the Resource.
11844        '''
11845        self.name = name if name is not None else ''
11846        '''
11847         Unique human-readable name of the Resource.
11848        '''
11849        self.password = password if password is not None else ''
11850        self.port = port if port is not None else 0
11851        self.port_override = port_override if port_override is not None else 0
11852        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11853        '''
11854         ID of the secret store containing credentials for this resource, if any.
11855        '''
11856        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11857        '''
11858         Tags is a map of key, value pairs.
11859        '''
11860        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11878    def to_dict(self):
11879        return {
11880            'bind_interface': self.bind_interface,
11881            'egress_filter': self.egress_filter,
11882            'healthy': self.healthy,
11883            'hostname': self.hostname,
11884            'id': self.id,
11885            'name': self.name,
11886            'password': self.password,
11887            'port': self.port,
11888            'port_override': self.port_override,
11889            'secret_store_id': self.secret_store_id,
11890            'tags': self.tags,
11891            'username': self.username,
11892        }
@classmethod
def from_dict(cls, d)
11894    @classmethod
11895    def from_dict(cls, d):
11896        return cls(
11897            bind_interface=d.get('bind_interface'),
11898            egress_filter=d.get('egress_filter'),
11899            healthy=d.get('healthy'),
11900            hostname=d.get('hostname'),
11901            id=d.get('id'),
11902            name=d.get('name'),
11903            password=d.get('password'),
11904            port=d.get('port'),
11905            port_override=d.get('port_override'),
11906            secret_store_id=d.get('secret_store_id'),
11907            tags=d.get('tags'),
11908            username=d.get('username'),
11909        )
class SybaseIQ:
11912class SybaseIQ:
11913    __slots__ = [
11914        'bind_interface',
11915        'egress_filter',
11916        'healthy',
11917        'hostname',
11918        'id',
11919        'name',
11920        'password',
11921        'port',
11922        'port_override',
11923        'secret_store_id',
11924        'tags',
11925        'username',
11926    ]
11927
11928    def __init__(
11929        self,
11930        bind_interface=None,
11931        egress_filter=None,
11932        healthy=None,
11933        hostname=None,
11934        id=None,
11935        name=None,
11936        password=None,
11937        port=None,
11938        port_override=None,
11939        secret_store_id=None,
11940        tags=None,
11941        username=None,
11942    ):
11943        self.bind_interface = bind_interface if bind_interface is not None else ''
11944        '''
11945         Bind interface
11946        '''
11947        self.egress_filter = egress_filter if egress_filter is not None else ''
11948        '''
11949         A filter applied to the routing logic to pin datasource to nodes.
11950        '''
11951        self.healthy = healthy if healthy is not None else False
11952        '''
11953         True if the datasource is reachable and the credentials are valid.
11954        '''
11955        self.hostname = hostname if hostname is not None else ''
11956        self.id = id if id is not None else ''
11957        '''
11958         Unique identifier of the Resource.
11959        '''
11960        self.name = name if name is not None else ''
11961        '''
11962         Unique human-readable name of the Resource.
11963        '''
11964        self.password = password if password is not None else ''
11965        self.port = port if port is not None else 0
11966        self.port_override = port_override if port_override is not None else 0
11967        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11968        '''
11969         ID of the secret store containing credentials for this resource, if any.
11970        '''
11971        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11972        '''
11973         Tags is a map of key, value pairs.
11974        '''
11975        self.username = username if username is not None else ''
11976
11977    def __repr__(self):
11978        return '<sdm.SybaseIQ ' + \
11979            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11980            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11981            'healthy: ' + repr(self.healthy) + ' ' +\
11982            'hostname: ' + repr(self.hostname) + ' ' +\
11983            'id: ' + repr(self.id) + ' ' +\
11984            'name: ' + repr(self.name) + ' ' +\
11985            'password: ' + repr(self.password) + ' ' +\
11986            'port: ' + repr(self.port) + ' ' +\
11987            'port_override: ' + repr(self.port_override) + ' ' +\
11988            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11989            'tags: ' + repr(self.tags) + ' ' +\
11990            'username: ' + repr(self.username) + ' ' +\
11991            '>'
11992
11993    def to_dict(self):
11994        return {
11995            'bind_interface': self.bind_interface,
11996            'egress_filter': self.egress_filter,
11997            'healthy': self.healthy,
11998            'hostname': self.hostname,
11999            'id': self.id,
12000            'name': self.name,
12001            'password': self.password,
12002            'port': self.port,
12003            'port_override': self.port_override,
12004            'secret_store_id': self.secret_store_id,
12005            'tags': self.tags,
12006            'username': self.username,
12007        }
12008
12009    @classmethod
12010    def from_dict(cls, d):
12011        return cls(
12012            bind_interface=d.get('bind_interface'),
12013            egress_filter=d.get('egress_filter'),
12014            healthy=d.get('healthy'),
12015            hostname=d.get('hostname'),
12016            id=d.get('id'),
12017            name=d.get('name'),
12018            password=d.get('password'),
12019            port=d.get('port'),
12020            port_override=d.get('port_override'),
12021            secret_store_id=d.get('secret_store_id'),
12022            tags=d.get('tags'),
12023            username=d.get('username'),
12024        )
SybaseIQ( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
11928    def __init__(
11929        self,
11930        bind_interface=None,
11931        egress_filter=None,
11932        healthy=None,
11933        hostname=None,
11934        id=None,
11935        name=None,
11936        password=None,
11937        port=None,
11938        port_override=None,
11939        secret_store_id=None,
11940        tags=None,
11941        username=None,
11942    ):
11943        self.bind_interface = bind_interface if bind_interface is not None else ''
11944        '''
11945         Bind interface
11946        '''
11947        self.egress_filter = egress_filter if egress_filter is not None else ''
11948        '''
11949         A filter applied to the routing logic to pin datasource to nodes.
11950        '''
11951        self.healthy = healthy if healthy is not None else False
11952        '''
11953         True if the datasource is reachable and the credentials are valid.
11954        '''
11955        self.hostname = hostname if hostname is not None else ''
11956        self.id = id if id is not None else ''
11957        '''
11958         Unique identifier of the Resource.
11959        '''
11960        self.name = name if name is not None else ''
11961        '''
11962         Unique human-readable name of the Resource.
11963        '''
11964        self.password = password if password is not None else ''
11965        self.port = port if port is not None else 0
11966        self.port_override = port_override if port_override is not None else 0
11967        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11968        '''
11969         ID of the secret store containing credentials for this resource, if any.
11970        '''
11971        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11972        '''
11973         Tags is a map of key, value pairs.
11974        '''
11975        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11993    def to_dict(self):
11994        return {
11995            'bind_interface': self.bind_interface,
11996            'egress_filter': self.egress_filter,
11997            'healthy': self.healthy,
11998            'hostname': self.hostname,
11999            'id': self.id,
12000            'name': self.name,
12001            'password': self.password,
12002            'port': self.port,
12003            'port_override': self.port_override,
12004            'secret_store_id': self.secret_store_id,
12005            'tags': self.tags,
12006            'username': self.username,
12007        }
@classmethod
def from_dict(cls, d)
12009    @classmethod
12010    def from_dict(cls, d):
12011        return cls(
12012            bind_interface=d.get('bind_interface'),
12013            egress_filter=d.get('egress_filter'),
12014            healthy=d.get('healthy'),
12015            hostname=d.get('hostname'),
12016            id=d.get('id'),
12017            name=d.get('name'),
12018            password=d.get('password'),
12019            port=d.get('port'),
12020            port_override=d.get('port_override'),
12021            secret_store_id=d.get('secret_store_id'),
12022            tags=d.get('tags'),
12023            username=d.get('username'),
12024        )
class Tag:
12027class Tag:
12028    __slots__ = [
12029        'name',
12030        'value',
12031    ]
12032
12033    def __init__(
12034        self,
12035        name=None,
12036        value=None,
12037    ):
12038        self.name = name if name is not None else ''
12039        self.value = value if value is not None else ''
12040
12041    def __repr__(self):
12042        return '<sdm.Tag ' + \
12043            'name: ' + repr(self.name) + ' ' +\
12044            'value: ' + repr(self.value) + ' ' +\
12045            '>'
12046
12047    def to_dict(self):
12048        return {
12049            'name': self.name,
12050            'value': self.value,
12051        }
12052
12053    @classmethod
12054    def from_dict(cls, d):
12055        return cls(
12056            name=d.get('name'),
12057            value=d.get('value'),
12058        )
Tag(name=None, value=None)
12033    def __init__(
12034        self,
12035        name=None,
12036        value=None,
12037    ):
12038        self.name = name if name is not None else ''
12039        self.value = value if value is not None else ''
name
value
def to_dict(self)
12047    def to_dict(self):
12048        return {
12049            'name': self.name,
12050            'value': self.value,
12051        }
@classmethod
def from_dict(cls, d)
12053    @classmethod
12054    def from_dict(cls, d):
12055        return cls(
12056            name=d.get('name'),
12057            value=d.get('value'),
12058        )
class Teradata:
12061class Teradata:
12062    __slots__ = [
12063        'bind_interface',
12064        'egress_filter',
12065        'healthy',
12066        'hostname',
12067        'id',
12068        'name',
12069        'password',
12070        'port',
12071        'port_override',
12072        'secret_store_id',
12073        'tags',
12074        'username',
12075    ]
12076
12077    def __init__(
12078        self,
12079        bind_interface=None,
12080        egress_filter=None,
12081        healthy=None,
12082        hostname=None,
12083        id=None,
12084        name=None,
12085        password=None,
12086        port=None,
12087        port_override=None,
12088        secret_store_id=None,
12089        tags=None,
12090        username=None,
12091    ):
12092        self.bind_interface = bind_interface if bind_interface is not None else ''
12093        '''
12094         Bind interface
12095        '''
12096        self.egress_filter = egress_filter if egress_filter is not None else ''
12097        '''
12098         A filter applied to the routing logic to pin datasource to nodes.
12099        '''
12100        self.healthy = healthy if healthy is not None else False
12101        '''
12102         True if the datasource is reachable and the credentials are valid.
12103        '''
12104        self.hostname = hostname if hostname is not None else ''
12105        self.id = id if id is not None else ''
12106        '''
12107         Unique identifier of the Resource.
12108        '''
12109        self.name = name if name is not None else ''
12110        '''
12111         Unique human-readable name of the Resource.
12112        '''
12113        self.password = password if password is not None else ''
12114        self.port = port if port is not None else 0
12115        self.port_override = port_override if port_override is not None else 0
12116        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12117        '''
12118         ID of the secret store containing credentials for this resource, if any.
12119        '''
12120        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12121        '''
12122         Tags is a map of key, value pairs.
12123        '''
12124        self.username = username if username is not None else ''
12125
12126    def __repr__(self):
12127        return '<sdm.Teradata ' + \
12128            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12129            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12130            'healthy: ' + repr(self.healthy) + ' ' +\
12131            'hostname: ' + repr(self.hostname) + ' ' +\
12132            'id: ' + repr(self.id) + ' ' +\
12133            'name: ' + repr(self.name) + ' ' +\
12134            'password: ' + repr(self.password) + ' ' +\
12135            'port: ' + repr(self.port) + ' ' +\
12136            'port_override: ' + repr(self.port_override) + ' ' +\
12137            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12138            'tags: ' + repr(self.tags) + ' ' +\
12139            'username: ' + repr(self.username) + ' ' +\
12140            '>'
12141
12142    def to_dict(self):
12143        return {
12144            'bind_interface': self.bind_interface,
12145            'egress_filter': self.egress_filter,
12146            'healthy': self.healthy,
12147            'hostname': self.hostname,
12148            'id': self.id,
12149            'name': self.name,
12150            'password': self.password,
12151            'port': self.port,
12152            'port_override': self.port_override,
12153            'secret_store_id': self.secret_store_id,
12154            'tags': self.tags,
12155            'username': self.username,
12156        }
12157
12158    @classmethod
12159    def from_dict(cls, d):
12160        return cls(
12161            bind_interface=d.get('bind_interface'),
12162            egress_filter=d.get('egress_filter'),
12163            healthy=d.get('healthy'),
12164            hostname=d.get('hostname'),
12165            id=d.get('id'),
12166            name=d.get('name'),
12167            password=d.get('password'),
12168            port=d.get('port'),
12169            port_override=d.get('port_override'),
12170            secret_store_id=d.get('secret_store_id'),
12171            tags=d.get('tags'),
12172            username=d.get('username'),
12173        )
Teradata( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12077    def __init__(
12078        self,
12079        bind_interface=None,
12080        egress_filter=None,
12081        healthy=None,
12082        hostname=None,
12083        id=None,
12084        name=None,
12085        password=None,
12086        port=None,
12087        port_override=None,
12088        secret_store_id=None,
12089        tags=None,
12090        username=None,
12091    ):
12092        self.bind_interface = bind_interface if bind_interface is not None else ''
12093        '''
12094         Bind interface
12095        '''
12096        self.egress_filter = egress_filter if egress_filter is not None else ''
12097        '''
12098         A filter applied to the routing logic to pin datasource to nodes.
12099        '''
12100        self.healthy = healthy if healthy is not None else False
12101        '''
12102         True if the datasource is reachable and the credentials are valid.
12103        '''
12104        self.hostname = hostname if hostname is not None else ''
12105        self.id = id if id is not None else ''
12106        '''
12107         Unique identifier of the Resource.
12108        '''
12109        self.name = name if name is not None else ''
12110        '''
12111         Unique human-readable name of the Resource.
12112        '''
12113        self.password = password if password is not None else ''
12114        self.port = port if port is not None else 0
12115        self.port_override = port_override if port_override is not None else 0
12116        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12117        '''
12118         ID of the secret store containing credentials for this resource, if any.
12119        '''
12120        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12121        '''
12122         Tags is a map of key, value pairs.
12123        '''
12124        self.username = username if username is not None else ''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12142    def to_dict(self):
12143        return {
12144            'bind_interface': self.bind_interface,
12145            'egress_filter': self.egress_filter,
12146            'healthy': self.healthy,
12147            'hostname': self.hostname,
12148            'id': self.id,
12149            'name': self.name,
12150            'password': self.password,
12151            'port': self.port,
12152            'port_override': self.port_override,
12153            'secret_store_id': self.secret_store_id,
12154            'tags': self.tags,
12155            'username': self.username,
12156        }
@classmethod
def from_dict(cls, d)
12158    @classmethod
12159    def from_dict(cls, d):
12160        return cls(
12161            bind_interface=d.get('bind_interface'),
12162            egress_filter=d.get('egress_filter'),
12163            healthy=d.get('healthy'),
12164            hostname=d.get('hostname'),
12165            id=d.get('id'),
12166            name=d.get('name'),
12167            password=d.get('password'),
12168            port=d.get('port'),
12169            port_override=d.get('port_override'),
12170            secret_store_id=d.get('secret_store_id'),
12171            tags=d.get('tags'),
12172            username=d.get('username'),
12173        )
class UpdateResponseMetadata:
12176class UpdateResponseMetadata:
12177    '''
12178         UpdateResponseMetadata is reserved for future use.
12179    '''
12180    __slots__ = []
12181
12182    def __init__(self, ):
12183        pass
12184
12185    def __repr__(self):
12186        return '<sdm.UpdateResponseMetadata ' + \
12187            '>'
12188
12189    def to_dict(self):
12190        return {}
12191
12192    @classmethod
12193    def from_dict(cls, d):
12194        return cls()

UpdateResponseMetadata is reserved for future use.

UpdateResponseMetadata()
12182    def __init__(self, ):
12183        pass
def to_dict(self)
12189    def to_dict(self):
12190        return {}
@classmethod
def from_dict(cls, d)
12192    @classmethod
12193    def from_dict(cls, d):
12194        return cls()
class User:
12197class User:
12198    '''
12199         A User can connect to resources they are granted directly, or granted
12200     via roles.
12201    '''
12202    __slots__ = [
12203        'email',
12204        'external_id',
12205        'first_name',
12206        'id',
12207        'last_name',
12208        'managed_by',
12209        'permission_level',
12210        'suspended',
12211        'tags',
12212    ]
12213
12214    def __init__(
12215        self,
12216        email=None,
12217        external_id=None,
12218        first_name=None,
12219        id=None,
12220        last_name=None,
12221        managed_by=None,
12222        permission_level=None,
12223        suspended=None,
12224        tags=None,
12225    ):
12226        self.email = email if email is not None else ''
12227        '''
12228         The User's email address. Must be unique.
12229        '''
12230        self.external_id = external_id if external_id is not None else ''
12231        '''
12232         External ID is an alternative unique ID this user is represented by within an external service.
12233        '''
12234        self.first_name = first_name if first_name is not None else ''
12235        '''
12236         The User's first name.
12237        '''
12238        self.id = id if id is not None else ''
12239        '''
12240         Unique identifier of the User.
12241        '''
12242        self.last_name = last_name if last_name is not None else ''
12243        '''
12244         The User's last name.
12245        '''
12246        self.managed_by = managed_by if managed_by is not None else ''
12247        '''
12248         Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.
12249        '''
12250        self.permission_level = permission_level if permission_level is not None else ''
12251        '''
12252         PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.
12253        '''
12254        self.suspended = suspended if suspended is not None else False
12255        '''
12256         The User's suspended state.
12257        '''
12258        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12259        '''
12260         Tags is a map of key, value pairs.
12261        '''
12262
12263    def __repr__(self):
12264        return '<sdm.User ' + \
12265            'email: ' + repr(self.email) + ' ' +\
12266            'external_id: ' + repr(self.external_id) + ' ' +\
12267            'first_name: ' + repr(self.first_name) + ' ' +\
12268            'id: ' + repr(self.id) + ' ' +\
12269            'last_name: ' + repr(self.last_name) + ' ' +\
12270            'managed_by: ' + repr(self.managed_by) + ' ' +\
12271            'permission_level: ' + repr(self.permission_level) + ' ' +\
12272            'suspended: ' + repr(self.suspended) + ' ' +\
12273            'tags: ' + repr(self.tags) + ' ' +\
12274            '>'
12275
12276    def to_dict(self):
12277        return {
12278            'email': self.email,
12279            'external_id': self.external_id,
12280            'first_name': self.first_name,
12281            'id': self.id,
12282            'last_name': self.last_name,
12283            'managed_by': self.managed_by,
12284            'permission_level': self.permission_level,
12285            'suspended': self.suspended,
12286            'tags': self.tags,
12287        }
12288
12289    @classmethod
12290    def from_dict(cls, d):
12291        return cls(
12292            email=d.get('email'),
12293            external_id=d.get('external_id'),
12294            first_name=d.get('first_name'),
12295            id=d.get('id'),
12296            last_name=d.get('last_name'),
12297            managed_by=d.get('managed_by'),
12298            permission_level=d.get('permission_level'),
12299            suspended=d.get('suspended'),
12300            tags=d.get('tags'),
12301        )

A User can connect to resources they are granted directly, or granted via roles.

User( email=None, external_id=None, first_name=None, id=None, last_name=None, managed_by=None, permission_level=None, suspended=None, tags=None)
12214    def __init__(
12215        self,
12216        email=None,
12217        external_id=None,
12218        first_name=None,
12219        id=None,
12220        last_name=None,
12221        managed_by=None,
12222        permission_level=None,
12223        suspended=None,
12224        tags=None,
12225    ):
12226        self.email = email if email is not None else ''
12227        '''
12228         The User's email address. Must be unique.
12229        '''
12230        self.external_id = external_id if external_id is not None else ''
12231        '''
12232         External ID is an alternative unique ID this user is represented by within an external service.
12233        '''
12234        self.first_name = first_name if first_name is not None else ''
12235        '''
12236         The User's first name.
12237        '''
12238        self.id = id if id is not None else ''
12239        '''
12240         Unique identifier of the User.
12241        '''
12242        self.last_name = last_name if last_name is not None else ''
12243        '''
12244         The User's last name.
12245        '''
12246        self.managed_by = managed_by if managed_by is not None else ''
12247        '''
12248         Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.
12249        '''
12250        self.permission_level = permission_level if permission_level is not None else ''
12251        '''
12252         PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.
12253        '''
12254        self.suspended = suspended if suspended is not None else False
12255        '''
12256         The User's suspended state.
12257        '''
12258        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12259        '''
12260         Tags is a map of key, value pairs.
12261        '''
email

The User's email address. Must be unique.

external_id

External ID is an alternative unique ID this user is represented by within an external service.

first_name

The User's first name.

id

Unique identifier of the User.

last_name

The User's last name.

managed_by

Managed By is a read only field for what service manages this user, e.g. StrongDM, Okta, Azure.

permission_level

PermissionLevel is a read only field for the user's permission level e.g. admin, DBA, user.

suspended

The User's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
12276    def to_dict(self):
12277        return {
12278            'email': self.email,
12279            'external_id': self.external_id,
12280            'first_name': self.first_name,
12281            'id': self.id,
12282            'last_name': self.last_name,
12283            'managed_by': self.managed_by,
12284            'permission_level': self.permission_level,
12285            'suspended': self.suspended,
12286            'tags': self.tags,
12287        }
@classmethod
def from_dict(cls, d)
12289    @classmethod
12290    def from_dict(cls, d):
12291        return cls(
12292            email=d.get('email'),
12293            external_id=d.get('external_id'),
12294            first_name=d.get('first_name'),
12295            id=d.get('id'),
12296            last_name=d.get('last_name'),
12297            managed_by=d.get('managed_by'),
12298            permission_level=d.get('permission_level'),
12299            suspended=d.get('suspended'),
12300            tags=d.get('tags'),
12301        )
class VaultAppRoleStore:
12304class VaultAppRoleStore:
12305    __slots__ = [
12306        'id',
12307        'name',
12308        'namespace',
12309        'server_address',
12310        'tags',
12311    ]
12312
12313    def __init__(
12314        self,
12315        id=None,
12316        name=None,
12317        namespace=None,
12318        server_address=None,
12319        tags=None,
12320    ):
12321        self.id = id if id is not None else ''
12322        '''
12323         Unique identifier of the SecretStore.
12324        '''
12325        self.name = name if name is not None else ''
12326        '''
12327         Unique human-readable name of the SecretStore.
12328        '''
12329        self.namespace = namespace if namespace is not None else ''
12330        self.server_address = server_address if server_address is not None else ''
12331        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12332        '''
12333         Tags is a map of key, value pairs.
12334        '''
12335
12336    def __repr__(self):
12337        return '<sdm.VaultAppRoleStore ' + \
12338            'id: ' + repr(self.id) + ' ' +\
12339            'name: ' + repr(self.name) + ' ' +\
12340            'namespace: ' + repr(self.namespace) + ' ' +\
12341            'server_address: ' + repr(self.server_address) + ' ' +\
12342            'tags: ' + repr(self.tags) + ' ' +\
12343            '>'
12344
12345    def to_dict(self):
12346        return {
12347            'id': self.id,
12348            'name': self.name,
12349            'namespace': self.namespace,
12350            'server_address': self.server_address,
12351            'tags': self.tags,
12352        }
12353
12354    @classmethod
12355    def from_dict(cls, d):
12356        return cls(
12357            id=d.get('id'),
12358            name=d.get('name'),
12359            namespace=d.get('namespace'),
12360            server_address=d.get('server_address'),
12361            tags=d.get('tags'),
12362        )
VaultAppRoleStore(id=None, name=None, namespace=None, server_address=None, tags=None)
12313    def __init__(
12314        self,
12315        id=None,
12316        name=None,
12317        namespace=None,
12318        server_address=None,
12319        tags=None,
12320    ):
12321        self.id = id if id is not None else ''
12322        '''
12323         Unique identifier of the SecretStore.
12324        '''
12325        self.name = name if name is not None else ''
12326        '''
12327         Unique human-readable name of the SecretStore.
12328        '''
12329        self.namespace = namespace if namespace is not None else ''
12330        self.server_address = server_address if server_address is not None else ''
12331        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12332        '''
12333         Tags is a map of key, value pairs.
12334        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12345    def to_dict(self):
12346        return {
12347            'id': self.id,
12348            'name': self.name,
12349            'namespace': self.namespace,
12350            'server_address': self.server_address,
12351            'tags': self.tags,
12352        }
@classmethod
def from_dict(cls, d)
12354    @classmethod
12355    def from_dict(cls, d):
12356        return cls(
12357            id=d.get('id'),
12358            name=d.get('name'),
12359            namespace=d.get('namespace'),
12360            server_address=d.get('server_address'),
12361            tags=d.get('tags'),
12362        )
class VaultTLSStore:
12365class VaultTLSStore:
12366    __slots__ = [
12367        'ca_cert_path',
12368        'client_cert_path',
12369        'client_key_path',
12370        'id',
12371        'name',
12372        'namespace',
12373        'server_address',
12374        'tags',
12375    ]
12376
12377    def __init__(
12378        self,
12379        ca_cert_path=None,
12380        client_cert_path=None,
12381        client_key_path=None,
12382        id=None,
12383        name=None,
12384        namespace=None,
12385        server_address=None,
12386        tags=None,
12387    ):
12388        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12389        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12390        self.client_key_path = client_key_path if client_key_path is not None else ''
12391        self.id = id if id is not None else ''
12392        '''
12393         Unique identifier of the SecretStore.
12394        '''
12395        self.name = name if name is not None else ''
12396        '''
12397         Unique human-readable name of the SecretStore.
12398        '''
12399        self.namespace = namespace if namespace is not None else ''
12400        self.server_address = server_address if server_address is not None else ''
12401        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12402        '''
12403         Tags is a map of key, value pairs.
12404        '''
12405
12406    def __repr__(self):
12407        return '<sdm.VaultTLSStore ' + \
12408            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
12409            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
12410            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
12411            'id: ' + repr(self.id) + ' ' +\
12412            'name: ' + repr(self.name) + ' ' +\
12413            'namespace: ' + repr(self.namespace) + ' ' +\
12414            'server_address: ' + repr(self.server_address) + ' ' +\
12415            'tags: ' + repr(self.tags) + ' ' +\
12416            '>'
12417
12418    def to_dict(self):
12419        return {
12420            'ca_cert_path': self.ca_cert_path,
12421            'client_cert_path': self.client_cert_path,
12422            'client_key_path': self.client_key_path,
12423            'id': self.id,
12424            'name': self.name,
12425            'namespace': self.namespace,
12426            'server_address': self.server_address,
12427            'tags': self.tags,
12428        }
12429
12430    @classmethod
12431    def from_dict(cls, d):
12432        return cls(
12433            ca_cert_path=d.get('ca_cert_path'),
12434            client_cert_path=d.get('client_cert_path'),
12435            client_key_path=d.get('client_key_path'),
12436            id=d.get('id'),
12437            name=d.get('name'),
12438            namespace=d.get('namespace'),
12439            server_address=d.get('server_address'),
12440            tags=d.get('tags'),
12441        )
VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None)
12377    def __init__(
12378        self,
12379        ca_cert_path=None,
12380        client_cert_path=None,
12381        client_key_path=None,
12382        id=None,
12383        name=None,
12384        namespace=None,
12385        server_address=None,
12386        tags=None,
12387    ):
12388        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
12389        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
12390        self.client_key_path = client_key_path if client_key_path is not None else ''
12391        self.id = id if id is not None else ''
12392        '''
12393         Unique identifier of the SecretStore.
12394        '''
12395        self.name = name if name is not None else ''
12396        '''
12397         Unique human-readable name of the SecretStore.
12398        '''
12399        self.namespace = namespace if namespace is not None else ''
12400        self.server_address = server_address if server_address is not None else ''
12401        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12402        '''
12403         Tags is a map of key, value pairs.
12404        '''
ca_cert_path
client_cert_path
client_key_path
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12418    def to_dict(self):
12419        return {
12420            'ca_cert_path': self.ca_cert_path,
12421            'client_cert_path': self.client_cert_path,
12422            'client_key_path': self.client_key_path,
12423            'id': self.id,
12424            'name': self.name,
12425            'namespace': self.namespace,
12426            'server_address': self.server_address,
12427            'tags': self.tags,
12428        }
@classmethod
def from_dict(cls, d)
12430    @classmethod
12431    def from_dict(cls, d):
12432        return cls(
12433            ca_cert_path=d.get('ca_cert_path'),
12434            client_cert_path=d.get('client_cert_path'),
12435            client_key_path=d.get('client_key_path'),
12436            id=d.get('id'),
12437            name=d.get('name'),
12438            namespace=d.get('namespace'),
12439            server_address=d.get('server_address'),
12440            tags=d.get('tags'),
12441        )
class VaultTokenStore:
12444class VaultTokenStore:
12445    __slots__ = [
12446        'id',
12447        'name',
12448        'namespace',
12449        'server_address',
12450        'tags',
12451    ]
12452
12453    def __init__(
12454        self,
12455        id=None,
12456        name=None,
12457        namespace=None,
12458        server_address=None,
12459        tags=None,
12460    ):
12461        self.id = id if id is not None else ''
12462        '''
12463         Unique identifier of the SecretStore.
12464        '''
12465        self.name = name if name is not None else ''
12466        '''
12467         Unique human-readable name of the SecretStore.
12468        '''
12469        self.namespace = namespace if namespace is not None else ''
12470        self.server_address = server_address if server_address is not None else ''
12471        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12472        '''
12473         Tags is a map of key, value pairs.
12474        '''
12475
12476    def __repr__(self):
12477        return '<sdm.VaultTokenStore ' + \
12478            'id: ' + repr(self.id) + ' ' +\
12479            'name: ' + repr(self.name) + ' ' +\
12480            'namespace: ' + repr(self.namespace) + ' ' +\
12481            'server_address: ' + repr(self.server_address) + ' ' +\
12482            'tags: ' + repr(self.tags) + ' ' +\
12483            '>'
12484
12485    def to_dict(self):
12486        return {
12487            'id': self.id,
12488            'name': self.name,
12489            'namespace': self.namespace,
12490            'server_address': self.server_address,
12491            'tags': self.tags,
12492        }
12493
12494    @classmethod
12495    def from_dict(cls, d):
12496        return cls(
12497            id=d.get('id'),
12498            name=d.get('name'),
12499            namespace=d.get('namespace'),
12500            server_address=d.get('server_address'),
12501            tags=d.get('tags'),
12502        )
VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
12453    def __init__(
12454        self,
12455        id=None,
12456        name=None,
12457        namespace=None,
12458        server_address=None,
12459        tags=None,
12460    ):
12461        self.id = id if id is not None else ''
12462        '''
12463         Unique identifier of the SecretStore.
12464        '''
12465        self.name = name if name is not None else ''
12466        '''
12467         Unique human-readable name of the SecretStore.
12468        '''
12469        self.namespace = namespace if namespace is not None else ''
12470        self.server_address = server_address if server_address is not None else ''
12471        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12472        '''
12473         Tags is a map of key, value pairs.
12474        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
12485    def to_dict(self):
12486        return {
12487            'id': self.id,
12488            'name': self.name,
12489            'namespace': self.namespace,
12490            'server_address': self.server_address,
12491            'tags': self.tags,
12492        }
@classmethod
def from_dict(cls, d)
12494    @classmethod
12495    def from_dict(cls, d):
12496        return cls(
12497            id=d.get('id'),
12498            name=d.get('name'),
12499            namespace=d.get('namespace'),
12500            server_address=d.get('server_address'),
12501            tags=d.get('tags'),
12502        )